picky 3.0.1 → 3.1.0

data/spec/lib/backends/memory_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe Picky::Backends::Memory do
+
+  before(:each) do
+    @backend = described_class.new
+
+    @backend.stub! :timed_exclaim
+  end
+  
+  describe 'create_...' do
+    [
+      [:inverted,      Picky::Backends::File::JSON],
+      [:weights,       Picky::Backends::File::JSON],
+      [:similarity,    Picky::Backends::File::Marshal],
+      [:configuration, Picky::Backends::File::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
+  
+  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

data/spec/lib/{backend → backends}/redis/basic_spec.rb

@@ -1,35 +1,36 @@
 require 'spec_helper'
 
-describe Picky::Backend::Redis::Basic do
+describe Picky::Backends::Redis::Basic do
   
-  let(:redis) { described_class.new "some_namespace" }
+  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
-      redis.should_receive(:backend).never
+      index.should_receive(:client).never
       
-      redis.load
-      redis.retrieve
-      redis.backup
-      redis.delete
+      index.load
+      index.retrieve
+      index.backup
+      index.delete
     end
   end
   
   describe 'cache_small?' do
     context 'size 0' do
       before(:each) do
-        redis.stub! :size => 0
+        index.stub! :size => 0
       end
       it 'is small' do
-        redis.cache_small?.should == true
+        index.cache_small?.should == true
       end
     end
     context 'size 1' do
       before(:each) do
-        redis.stub! :size => 1
+        index.stub! :size => 1
       end
       it 'is not small' do
-        redis.cache_small?.should == false
+        index.cache_small?.should == false
       end
     end
   end
@@ -37,36 +38,33 @@ describe Picky::Backend::Redis::Basic do
   describe 'cache_ok?' do
     context 'size 0' do
       before(:each) do
-        redis.stub! :size => 0
+        index.stub! :size => 0
       end
       it 'is not ok' do
-        redis.cache_ok?.should == false
+        index.cache_ok?.should == false
       end
     end
     context 'size 1' do
       before(:each) do
-        redis.stub! :size => 1
+        index.stub! :size => 1
       end
       it 'is ok' do
-        redis.cache_ok?.should == true
+        index.cache_ok?.should == true
       end
     end
   end
   
   describe "size" do
     it 'delegates to the backend' do
-      backend = stub :backend
-      redis.stub! :backend => backend
+      client.should_receive(:dbsize).once.with
       
-      backend.should_receive(:dbsize).once.with
-      
-      redis.size
+      index.size
     end
   end
   
   describe 'to_s' do
     it 'returns the cache path with the default file extension' do
-      redis.to_s.should == 'Picky::Backend::Redis::Basic(some_namespace:*)'
+      index.to_s.should == 'Picky::Backends::Redis::Basic(some_namespace:*)'
     end
   end
   

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

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Picky::Backends::Redis::FloatHash do
+  
+  let(:client) { stub :client }
+  let(:backend) { described_class.new client, :some_namespace }
+    
+  describe 'dump' do
+    it 'dumps correctly' do
+      client.should_receive(:del).once.ordered.with  :some_namespace
+      client.should_receive(:hset).once.ordered.with :some_namespace, :a, 1
+      client.should_receive(:hset).once.ordered.with :some_namespace, :b, 2
+      client.should_receive(:hset).once.ordered.with :some_namespace, :c, 3
+      
+      backend.dump a: 1, b: 2, c: 3
+    end
+  end
+  
+  describe 'member' do
+    it 'delegates to the backend' do
+      client.should_receive(:hget).once.with :some_namespace, :some_symbol
+      
+      backend[:some_symbol]
+    end
+    it 'returns whatever it gets from the backend' do
+      client.should_receive(:hget).any_number_of_times.and_return '1.23'
+      
+      backend[:anything].should == 1.23
+    end
+  end
+  
+  describe 'to_s' do
+    it 'returns the cache path with the default file extension' do
+      backend.to_s.should == 'Picky::Backends::Redis::FloatHash(some_namespace:*)'
+    end
+  end
+  
+end

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

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Picky::Backends::Redis::ListHash do
+  
+  let(:client) { stub :client }
+  let(:index) { described_class.new client, :some_namespace }
+  
+  describe '[]' do
+    it 'returns whatever comes back from the backend' do
+      client.stub! :zrange => :some_lrange_result
+      
+      index[:anything].should == :some_lrange_result
+    end
+    it 'calls the right method on the backend' do
+      client.should_receive(:zrange).once.with "some_namespace:some_sym", 0, -1
+      
+      index[:some_sym]
+    end
+  end
+  
+  describe 'to_s' do
+    it 'returns the cache path with the default file extension' do
+      index.to_s.should == 'Picky::Backends::Redis::ListHash(some_namespace:*)'
+    end
+  end
+  
+end

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

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Picky::Backends::Redis::StringHash do
+  
+  let(:client) { stub :client }
+  let(:backend) { described_class.new client, :some_namespace }
+    
+  describe 'dump' do
+    it 'dumps correctly' do
+      client.should_receive(:del).once.ordered.with  :some_namespace
+      client.should_receive(:hset).once.ordered.with :some_namespace, :a, 1
+      client.should_receive(:hset).once.ordered.with :some_namespace, :b, 2
+      client.should_receive(:hset).once.ordered.with :some_namespace, :c, 3
+      
+      backend.dump a: 1, b: 2, c: 3
+    end
+  end
+  
+  describe 'member' do
+    it 'delegates to the backend' do
+      client.should_receive(:hget).once.with :some_namespace, :some_symbol
+      
+      backend[:some_symbol]
+    end
+    it 'returns whatever it gets from the backend' do
+      client.should_receive(:hget).any_number_of_times.and_return :some_result
+      
+      backend[:anything].should == :some_result
+    end
+  end
+  
+  describe 'to_s' do
+    it 'returns the cache path with the default file extension' do
+      backend.to_s.should == 'Picky::Backends::Redis::StringHash(some_namespace:*)'
+    end
+  end
+  
+end

data/spec/lib/backends/redis_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Picky::Backends::Redis do
+
+  before(:each) do
+    @backend = described_class.new
+
+    @backend.stub! :timed_exclaim
+  end
+  
+  describe 'create_...' do
+    [
+      [:inverted,      Picky::Backends::Redis::ListHash],
+      [:weights,       Picky::Backends::Redis::FloatHash],
+      [:similarity,    Picky::Backends::Redis::ListHash],
+      [:configuration, Picky::Backends::Redis::StringHash]
+    ].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

data/spec/lib/categories_indexed_spec.rb

@@ -22,7 +22,7 @@ describe Picky::Categories do
   
   context "with real categories" do
     before(:each) do
-      @index1 = Picky::Indexes::Memory.new :name
+      @index1 = Picky::Index.new :name
       
       @categories = described_class.new
       @categories << Picky::Category.new(:category1, @index1)
@@ -31,7 +31,7 @@ describe Picky::Categories do
     end
     describe "similar_possible_for" do
       before(:each) do
-        @token = Picky::Query::Token.processed 'similar~'
+        @token = Picky::Query::Token.processed 'similar~', 'Similar~'
       end
       it "returns possible categories" do
         @categories.similar_possible_for(@token).should == []
@@ -65,7 +65,7 @@ describe Picky::Categories do
   
   context 'without options' do
     before(:each) do
-      @index1 = Picky::Indexes::Memory.new :some_index
+      @index1 = Picky::Index.new :some_index
       
       @category1 = Picky::Category.new :category1, @index1
       @category2 = Picky::Category.new :category2, @index1

data/spec/lib/category_indexed_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Picky::Category do
 
   before(:each) do
-    @index = Picky::Indexes::Index.new :some_index do
+    @index = Picky::Index.new :some_index do
       source []
     end
     @partial_strategy    = stub :partial, :use_exact_for_partial? => false
@@ -31,18 +31,18 @@ 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::Memory)
+          @category.indexed_partial.should be_kind_of(Picky::Indexed::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::Memory)
+          @category.indexed_partial.should be_kind_of(Picky::Indexed::Bundle)
         end
       end
     end
     context 'indexed_bundle_class defined differently' do
       before(:each) do
-        index = Picky::Indexes::Redis.new(:some_index_name) do
+        index = Picky::Index.new(:some_index_name) do
           source []
         end
         @category = described_class.new :some_name, index
@@ -52,12 +52,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::Redis)
+          @category.indexed_partial.should be_kind_of(Picky::Indexed::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::Redis)
+          @category.indexed_partial.should be_kind_of(Picky::Indexed::Bundle)
         end
       end
     end

data/spec/lib/category_indexing_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe Picky::Category do
   
   before(:each) do
-    @index  = Picky::Indexes::Memory.new :some_index
+    @index  = Picky::Index.new :some_index
     @source = stub :some_given_source, :key_format => nil
   end
   let(:category) { described_class.new(:some_category, @index, :source => @source).tap { |c| c.stub! :timed_exclaim } }

data/spec/lib/category_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe Picky::Category do
   
-  let(:index) { Picky::Indexes::Memory.new :some_index }
+  let(:index) { Picky::Index.new :some_index }
   let(:category) { described_class.new :some_category, index }
   
   it 'should set defaults correctly' do

data/spec/lib/frontend_adapters/rack_spec.rb

@@ -54,7 +54,7 @@ describe Picky::FrontendAdapters::Rack do
       end
       describe 'to_s' do
         it 'outputs correctly' do
-          @rack_adapter.to_s.should == "Note: Anchored (✓) regexps are faster, e.g. /\\A.*\\Z/ or /^.*$/.\n\n   something => Picky::Search()"
+          @rack_adapter.to_s.should == "Note: Anchored (✓) regexps are faster, e.g. /\\A.*\\Z/ or /^.*$/.\n\n   something => Picky::Search(weights: Picky::Query::Weights({}))"
         end
       end
     end
@@ -63,7 +63,7 @@ describe Picky::FrontendAdapters::Rack do
   context 'real routes' do
     before(:each) do
       @rack_adapter.reset_routes
-      Picky.logger.stub! :log
+      Picky.logger.stub! :info
     end
     it 'should route correctly' do
       env = {}

data/spec/lib/{indexes/index_indexed_spec.rb → index_indexed_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Picky::Indexes::Index do
+describe Picky::Index do
   
   context 'without stubbed categories' do
     before(:each) do

data/spec/lib/{indexes/index_indexing_spec.rb → index_indexing_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Picky::Indexes::Index do
+describe Picky::Index do
   
   describe 'tokenizer' do
     context 'with tokenizer' do

data/spec/lib/{indexes/index_spec.rb → index_spec.rb}

@@ -2,7 +2,7 @@
 #
 require 'spec_helper'
 
-describe Picky::Indexes::Index do
+describe Picky::Index do
   
   let(:some_source) { stub :source, :harvest => nil, :inspect => 'some_source' }
   

data/spec/lib/indexed/{bundle/memory_spec.rb → memory_spec.rb}

@@ -1,27 +1,27 @@
 require 'spec_helper'
 
-describe Picky::Indexed::Bundle::Memory do
+describe Picky::Indexed::Bundle do
 
   before(:each) do
-    @index        = Picky::Indexes::Memory.new :some_index
+    @index        = Picky::Index.new :some_index
     @category     = Picky::Category.new :some_category, @index
     
     @similarity   = stub :similarity
-    @bundle       = described_class.new :some_name, @category, @similarity
+    @bundle       = described_class.new :some_name, @category, Picky::Backends::Memory.new, @similarity
   end
   
   describe 'to_s' do
     it 'does something' do
-      @bundle.to_s.should == "Picky::Indexed::Bundle::Memory(test:some_index:some_category:some_name)"
+      @bundle.to_s.should == "Picky::Indexed::Bundle(test:some_index:some_category:some_name)"
     end
   end
   
   describe 'clear_index' do
     before(:each) do
-      @bundle.instance_variable_set(:@inverted, :not_empty)
+      @bundle.instance_variable_set :@inverted, { :a => [] }
     end
     it 'has not cleared the inverted index' do
-      @bundle.inverted.should == :not_empty
+      @bundle.inverted.should == { :a => [] }
     end
     it 'clears the inverted index' do
       @bundle.clear_inverted
@@ -31,10 +31,10 @@ describe Picky::Indexed::Bundle::Memory do
   end
   describe 'clear_weights' do
     before(:each) do
-      @bundle.instance_variable_set(:@weights, :not_empty)
+      @bundle.instance_variable_set :@weights, { :a => 1.0 }
     end
     it 'has not cleared the weights' do
-      @bundle.weights.should == :not_empty
+      @bundle.weights.should == { :a => 1.0 }
     end
     it 'clears the weights' do
       @bundle.clear_weights
@@ -44,10 +44,10 @@ describe Picky::Indexed::Bundle::Memory do
   end
   describe 'clear_similarity' do
     before(:each) do
-      @bundle.instance_variable_set(:@similarity, :not_empty)
+      @bundle.instance_variable_set :@similarity, { :a => :aa }
     end
     it 'has not cleared the similarity index' do
-      @bundle.similarity.should == :not_empty
+      @bundle.similarity.should == { :a => :aa }
     end
     it 'clears the similarity index' do
       @bundle.clear_similarity
@@ -57,10 +57,10 @@ describe Picky::Indexed::Bundle::Memory do
   end
   describe 'clear_configuration' do
     before(:each) do
-      @bundle.instance_variable_set(:@configuration, :not_empty)
+      @bundle.instance_variable_set :@configuration, { :a => 'value' }
     end
     it 'has not cleared the similarity index' do
-      @bundle.configuration.should == :not_empty
+      @bundle.configuration.should == { :a => 'value' }
     end
     it 'clears the similarity index' do
       @bundle.clear_configuration
@@ -153,22 +153,22 @@ describe Picky::Indexed::Bundle::Memory do
   
   describe 'initialization' do
     before(:each) do
-      @index    = Picky::Indexes::Memory.new :some_index
+      @index    = Picky::Index.new :some_index
       @category = Picky::Category.new :some_category, @index
       
-      @bundle = described_class.new :some_name, @category, :similarity
+      @bundle = described_class.new :some_name, @category, Picky::Backends::Memory.new, :similarity
     end
     it 'should initialize the index correctly' do
-      @bundle.inverted.should == {}
+      @bundle.backend_inverted.should be_kind_of(Picky::Backends::File::JSON)
     end
     it 'should initialize the weights index correctly' do
-      @bundle.weights.should == {}
+      @bundle.backend_weights.should be_kind_of(Picky::Backends::File::JSON)
     end
     it 'should initialize the similarity index correctly' do
-      @bundle.similarity.should == {}
+      @bundle.backend_similarity.should be_kind_of(Picky::Backends::File::Marshal)
     end
     it 'should initialize the configuration correctly' do
-      @bundle.configuration.should == {}
+      @bundle.backend_configuration.should be_kind_of(Picky::Backends::File::JSON)
     end
     it 'should initialize the similarity strategy correctly' do
       @bundle.similarity_strategy.should == :similarity

data/spec/lib/indexed/wrappers/exact_first_spec.rb

@@ -13,7 +13,7 @@ describe Picky::Indexed::Wrappers::ExactFirst do
   describe "self.wrap" do
     context "index" do
       it "wraps each category" do
-        index = Picky::Indexes::Memory.new :some_index
+        index = Picky::Index.new :some_index
         index.define_category :some_category
         
         Picky::Indexed::Wrappers::ExactFirst.wrap index
@@ -23,7 +23,7 @@ describe Picky::Indexed::Wrappers::ExactFirst do
         end
       end
       it "returns the index" do
-        index = Picky::Indexes::Memory.new :some_index
+        index = Picky::Index.new :some_index
         index.define_category :some_category
         
         described_class.wrap(index).should == index

data/spec/lib/indexing/{bundle/memory_partial_generation_speed_spec.rb → bundle_partial_generation_speed_spec.rb}

@@ -1,13 +1,13 @@
 require 'spec_helper'
 
-describe Picky::Indexing::Bundle::Memory do
+describe Picky::Indexing::Bundle do
 
   before(:each) do
-    @index            = Picky::Indexes::Memory.new :some_index
+    @index            = Picky::Index.new :some_index
     @category         = Picky::Category.new :some_category, @index
     
     @partial_strategy = Picky::Generators::Partial::Substring.new :from => 1
-    @exact            = described_class.new :some_name, @category, nil, @partial_strategy, nil
+    @exact            = described_class.new :some_name, @category, Picky::Backends::Memory.new, nil, @partial_strategy, nil
   end
 
   def generate_random_keys amount