picky 3.2.0 → 3.3.0

data/spec/lib/backends/memory_spec.rb

@@ -2,75 +2,129 @@ require 'spec_helper'
 
 describe Picky::Backends::Memory do
 
-  before(:each) do
-    @backend = described_class.new
+  context 'with options' do
+    before(:each) do
+      @backend = described_class.new inverted:      Picky::Backends::Memory::Marshal.new(:unimportant),
+                                     weights:       Picky::Backends::Memory::Marshal.new(:unimportant),
+                                     similarity:    Picky::Backends::Memory::JSON.new(:unimportant),
+                                     configuration: Picky::Backends::Memory::Marshal.new(:unimportant)
 
-    @backend.stub! :timed_exclaim
-  end
+      @backend.stub! :timed_exclaim
+    end
   
-  describe 'create_...' do
-    [
-      [:inverted,      Picky::Backends::Memory::JSON],
-      [:weights,       Picky::Backends::Memory::JSON],
-      [:similarity,    Picky::Backends::Memory::Marshal],
-      [:configuration, Picky::Backends::Memory::JSON]
-    ].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)
+    describe 'create_...' do
+      [
+        [:inverted,      Picky::Backends::Memory::Marshal],
+        [:weights,       Picky::Backends::Memory::Marshal],
+        [:similarity,    Picky::Backends::Memory::JSON],
+        [:configuration, Picky::Backends::Memory::Marshal]
+      ].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
   
-  describe "ids" do
+  context 'with lambda options' 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 = described_class.new inverted:      ->(bundle){ Picky::Backends::Memory::Marshal.new(bundle.index_path(:inverted)) },
+                                     weights:       ->(bundle){ Picky::Backends::Memory::Marshal.new(bundle.index_path(:weights)) },
+                                     similarity:    ->(bundle){ Picky::Backends::Memory::JSON.new(bundle.index_path(:similarity)) },
+                                     configuration: ->(bundle){ Picky::Backends::Memory::Marshal.new(bundle.index_path(:configuration)) }
 
-      @backend.ids(@combinations, :any, :thing).should == (1..10).to_a
+      @backend.stub! :timed_exclaim
     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
+  
+    describe 'create_...' do
+      [
+        [:inverted,      Picky::Backends::Memory::Marshal],
+        [:weights,       Picky::Backends::Memory::Marshal],
+        [:similarity,    Picky::Backends::Memory::JSON],
+        [:configuration, Picky::Backends::Memory::Marshal]
+      ].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
-    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
+  end
 
-      @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
+  context 'without options' do
+    before(:each) do
+      @backend = described_class.new
 
-      performance_of { @backend.ids(@combinations, :any, :thing) }.should < 0.004
+      @backend.stub! :timed_exclaim
     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
+  
+    describe 'create_...' do
+      [
+        [:inverted,      Picky::Backends::Memory::JSON],
+        [:weights,       Picky::Backends::Memory::JSON],
+        [:similarity,    Picky::Backends::Memory::Marshal],
+        [:configuration, Picky::Backends::Memory::JSON]
+      ].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
-    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
+  
+    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
 
-      performance_of { @backend.ids(@combinations, :any, :thing) }.should < 0.0001
+        @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
 

data/spec/lib/backends/redis/basic_spec.rb

@@ -3,80 +3,104 @@ require 'spec_helper'
 describe Picky::Backends::Redis::Basic do
   
   let(:client) { stub :client }
-  let(:index) { described_class.new client, :some_namespace }
-
-  describe 'load, retrieve, backup, delete' do
-    it 'is nothing they do (at least on the backend)' do
-      index.should_receive(:client).never
-      
-      index.load
-      index.retrieve
-      index.backup
-      index.delete
-    end
-  end
-  
-  describe 'empty' do
-    it 'returns the container that is used for indexing' do
-      index.empty.should == {}
-    end
-  end
   
-  describe 'initial' do
-    it 'is correct' do
-      index.initial.class.should == described_class
+  context 'without options' do
+    let(:index) { described_class.new client, :some_namespace }
+
+    describe 'load, retrieve, backup, delete' do
+      it 'is nothing they do (at least on the backend)' do
+        index.should_receive(:client).never
+
+        index.load
+        index.retrieve
+        index.backup
+        index.delete
+      end
     end
-  end
-  
-  describe 'cache_small?' do
-    context 'size 0' do
-      before(:each) do
-        index.stub! :size => 0
+
+    describe 'empty' do
+      it 'returns the container that is used for indexing' do
+        index.empty.should == {}
       end
-      it 'is small' do
-        index.cache_small?.should == true
+    end
+
+    describe 'initial' do
+      it 'is correct' do
+        index.initial.class.should == described_class
       end
     end
-    context 'size 1' do
-      before(:each) do
-        index.stub! :size => 1
+
+    describe 'cache_small?' do
+      context 'size 0' do
+        before(:each) do
+          index.stub! :size => 0
+        end
+        it 'is small' do
+          index.cache_small?.should == true
+        end
       end
-      it 'is not small' do
-        index.cache_small?.should == false
+      context 'size 1' do
+        before(:each) do
+          index.stub! :size => 1
+        end
+        it 'is not small' do
+          index.cache_small?.should == false
+        end
       end
     end
-  end
-  
-  describe 'cache_ok?' do
-    context 'size 0' do
-      before(:each) do
-        index.stub! :size => 0
+
+    describe 'cache_ok?' do
+      context 'size 0' do
+        before(:each) do
+          index.stub! :size => 0
+        end
+        it 'is not ok' do
+          index.cache_ok?.should == false
+        end
       end
-      it 'is not ok' do
-        index.cache_ok?.should == false
+      context 'size 1' do
+        before(:each) do
+          index.stub! :size => 1
+        end
+        it 'is ok' do
+          index.cache_ok?.should == true
+        end
       end
     end
-    context 'size 1' do
-      before(:each) do
-        index.stub! :size => 1
+
+    describe "size" do
+      it 'delegates to the backend' do
+        client.should_receive(:dbsize).once.with
+
+        index.size
       end
-      it 'is ok' do
-        index.cache_ok?.should == true
+    end
+
+    describe 'to_s' do
+      it 'returns the cache path with the default file extension' do
+        index.to_s.should == 'Picky::Backends::Redis::Basic(some_namespace:*)'
       end
     end
   end
   
-  describe "size" do
-    it 'delegates to the backend' do
-      client.should_receive(:dbsize).once.with
-      
-      index.size
+  context 'with options' do
+    let(:index) do
+      described_class.new client,
+                          :some_namespace,
+                          empty: [],
+                          initial: []
     end
-  end
-  
-  describe 'to_s' do
-    it 'returns the cache path with the default file extension' do
-      index.to_s.should == 'Picky::Backends::Redis::Basic(some_namespace:*)'
+
+    describe 'empty' do
+      it 'returns the container that is used for indexing' do
+        index.empty.should == []
+      end
+    end
+
+    describe 'initial' do
+      it 'is correct' do
+        index.initial.class.should == Array
+      end
     end
   end
   

data/spec/lib/backends/redis_spec.rb

@@ -2,78 +2,132 @@ require 'spec_helper'
 
 describe Picky::Backends::Redis do
 
-  before(:each) do
-    @backend = described_class.new
+  context 'with options' do
+    before(:each) do
+      @backend = described_class.new inverted:      Picky::Backends::Redis::Float.new(:unimportant, :unimportant),
+                                     weights:       Picky::Backends::Redis::String.new(:unimportant, :unimportant),
+                                     similarity:    Picky::Backends::Redis::Float.new(:unimportant, :unimportant),
+                                     configuration: Picky::Backends::Redis::List.new(:unimportant, :unimportant)
 
-    @backend.stub! :timed_exclaim
+      @backend.stub! :timed_exclaim
+    end
+  
+    describe 'create_...' do
+      [
+        [:inverted,      Picky::Backends::Redis::Float],
+        [:weights,       Picky::Backends::Redis::String],
+        [:similarity,    Picky::Backends::Redis::Float],
+        [:configuration, Picky::Backends::Redis::List]
+      ].each do |type, kind|
+        it "creates and returns a(n) #{type} index" do
+          @backend.send(:"create_#{type}",
+                        stub(type, :identifier => "some_identifier:#{type}")
+          ).should be_kind_of(kind)
+        end
+      end
+    end
   end
   
-  describe 'create_...' do
-    [
-      [:inverted,      Picky::Backends::Redis::List],
-      [:weights,       Picky::Backends::Redis::Float],
-      [:similarity,    Picky::Backends::Redis::List],
-      [:configuration, Picky::Backends::Redis::String]
-    ].each do |type, kind|
-      it "creates and returns a(n) #{type} index" do
-        @backend.send(:"create_#{type}",
-                      stub(type, :identifier => "some_identifier:#{type}")
-        ).should be_kind_of(kind)
+  context 'with lambda options' do
+    before(:each) do
+      @backend = described_class.new inverted:      ->(client, bundle){ Picky::Backends::Redis::Float.new(client, bundle.identifier(:inverted)) },
+                                     weights:       ->(client, bundle){ Picky::Backends::Redis::String.new(client, bundle.identifier(:weights)) },
+                                     similarity:    ->(client, bundle){ Picky::Backends::Redis::Float.new(client, bundle.identifier(:similarity)) },
+                                     configuration: ->(client, bundle){ Picky::Backends::Redis::List.new(client, bundle.identifier(:configuration)) }
+
+      @backend.stub! :timed_exclaim
+    end
+  
+    describe 'create_...' do
+      [
+        [:inverted,      Picky::Backends::Redis::Float],
+        [:weights,       Picky::Backends::Redis::String],
+        [:similarity,    Picky::Backends::Redis::Float],
+        [:configuration, Picky::Backends::Redis::List]
+      ].each do |type, kind|
+        it "creates and returns a(n) #{type} index" do
+          to_a_able_stub = Object.new
+          to_a_able_stub.stub! :identifier => "some_identifier:#{type}"
+          @backend.send(:"create_#{type}", to_a_able_stub).should be_kind_of(kind)
+        end
       end
     end
   end
 
-  # TODO
-  #
-  # 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
+  context 'without options' do
+    before(:each) do
+      @backend = described_class.new
+
+      @backend.stub! :timed_exclaim
+    end
+  
+    describe 'create_...' do
+      [
+        [:inverted,      Picky::Backends::Redis::List],
+        [:weights,       Picky::Backends::Redis::Float],
+        [:similarity,    Picky::Backends::Redis::List],
+        [:configuration, Picky::Backends::Redis::String]
+      ].each do |type, kind|
+        it "creates and returns a(n) #{type} index" do
+          @backend.send(:"create_#{type}",
+                        stub(type, :identifier => "some_identifier:#{type}")
+          ).should be_kind_of(kind)
+        end
+      end
+    end
+
+    # TODO
+    #
+    # 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

@@ -9,18 +9,18 @@ describe Picky::Category do
     @partial_strategy    = stub :partial, :use_exact_for_partial? => false
     @weights_strategy    = stub :weights
     @similarity_strategy = stub :similarity
-    
+
     @exact   = stub :exact, :dump => nil
     @partial = stub :partial, :dump => nil
-    
+
     @category = described_class.new :some_name, @index, :partial    => @partial_strategy,
                                                         :weights    => @weights_strategy,
                                                         :similarity => @similarity_strategy,
                                                         :qualifiers => [:q, :qualifier]
-    
+
     @category.stub! :exclaim
   end
-  
+
   describe 'partial' do
     context 'default' do
       before(:each) do
@@ -31,12 +31,12 @@ describe Picky::Category do
           @partial_strategy.stub! :use_exact_for_partial? => true
         end
         it 'returns the partial index' do
-          @category.indexed_partial.should be_kind_of(Picky::Indexed::Bundle)
+          @category.partial.should be_kind_of(Picky::Bundle)
         end
       end
       context 'with a partial strategy that uses the partial index (default)' do
         it 'returns the partial index' do
-          @category.indexed_partial.should be_kind_of(Picky::Indexed::Bundle)
+          @category.partial.should be_kind_of(Picky::Bundle)
         end
       end
     end
@@ -52,17 +52,17 @@ describe Picky::Category do
           @partial_strategy.stub! :use_exact_for_partial? => true
         end
         it 'returns the partial index' do
-          @category.indexed_partial.should be_kind_of(Picky::Indexed::Bundle)
+          @category.partial.should be_kind_of(Picky::Bundle)
         end
       end
       context 'with a partial strategy that uses the partial index (default)' do
         it 'returns the partial index' do
-          @category.indexed_partial.should be_kind_of(Picky::Indexed::Bundle)
+          @category.partial.should be_kind_of(Picky::Bundle)
         end
       end
     end
   end
-  
+
   describe 'weight' do
     before(:each) do
       @token = stub :token, :text => :some_text
@@ -139,11 +139,11 @@ describe Picky::Category do
       end
     end
   end
-  
+
   context 'stubbed exact/partial' do
     before(:each) do
-      @category.stub! :indexed_exact => (@exact = stub :exact)
-      @category.stub! :indexed_partial => (@partial = stub :partial)
+      @category.stub! :exact => (@exact = stub :exact)
+      @category.stub! :partial => (@partial = stub :partial)
     end
     describe 'bundle_for' do
       it 'should return the right bundle' do