picky 3.6.16 → 4.0.0pre1

data/spec/lib/generators/similarity/phonetic_spec.rb

@@ -10,4 +10,50 @@ describe Picky::Generators::Similarity::Phonetic do
     }.to raise_error("In Picky 2.0+, the Similarity::Phonetic has been renamed to Similarity::DoubleMetaphone. Please use that one. Thanks!")
   end
 
+  describe 'sort!' do
+    let(:phonetic) { described_class.allocate }
+    it 'sorts correctly' do
+      phonetic.instance_variable_set :@amount, 2
+
+      ary = [:a, :b, :c]
+      phonetic.sort ary, :b
+      ary.should == [:b, :a]
+    end
+    it 'sorts correctly' do
+      phonetic.instance_variable_set :@amount, 2
+
+      ary = [:aaa, :aa, :aaaa]
+      phonetic.sort ary, :aaa
+      ary.should == [:aaa, :aa]
+    end
+    it 'sorts correctly' do
+      phonetic.instance_variable_set :@amount, 3
+
+      ary = [:aaa, :aa, :aaaa]
+      phonetic.sort ary, :aaa
+      ary.should == [:aaa, :aa, :aaaa]
+    end
+    it 'sorts correctly' do
+      phonetic.instance_variable_set :@amount, 3
+
+      ary = [:aaaaa, :aa, :aaaa]
+      phonetic.sort ary, :aaa
+      ary.should == [:aaaa, :aa, :aaaaa]
+    end
+    it 'sorts correctly' do
+      phonetic.instance_variable_set :@amount, 3
+
+      ary = [:aaaaa, :aa]
+      phonetic.sort ary, :aaa
+      ary.should == [:aa, :aaaaa]
+    end
+    it 'sorts correctly' do
+      phonetic.instance_variable_set :@amount, 3
+
+      ary = [:aaa]
+      phonetic.sort ary, :aaa
+      ary.should == [:aaa]
+    end
+  end
+
 end

data/spec/lib/index_indexed_spec.rb

@@ -7,14 +7,14 @@ describe Picky::Index do
       @index = described_class.new :some_index_name
     end
 
-    describe 'define_category' do
+    describe 'category' do
       it 'adds a new category to the categories' do
-        @index.define_category :some_category_name
+        @index.category :some_category_name
 
         @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)
+        @index.category(:some_category_name).should be_kind_of(Picky::Category)
       end
     end
   end
@@ -24,8 +24,8 @@ describe Picky::Index do
       @categories = stub :categories
 
       @index = described_class.new :some_name
-      @index.define_category :some_category_name1
-      @index.define_category :some_category_name2
+      @index.category :some_category_name1
+      @index.category :some_category_name2
 
       @index.stub! :categories => @categories
     end

data/spec/lib/index_indexing_spec.rb

@@ -55,16 +55,16 @@ describe Picky::Index do
   context 'in general' do
     context 'with #each source' do
       let(:index) do
-        described_class.new :some_name do
-          source []
-        end
+        described_class.new :some_name
       end
 
       it 'does things in order' do
-        index.should_receive(:check_source_empty).once.with.ordered
-        index.should_receive(:index_in_parallel).once.with.ordered
+        scheduler = stub :scheduler, :fork? => false, :finish => nil
 
-        index.index
+        index.should_receive(:prepare).once.with(scheduler).ordered
+        index.should_receive(:cache).once.with(scheduler).ordered
+
+        index.index scheduler
       end
     end
     context 'with non#each source' do
@@ -80,7 +80,8 @@ describe Picky::Index do
         categories = stub :categories
         index.stub! :categories => categories
 
-        categories.should_receive(:index).once
+        categories.should_receive(:prepare).once
+        categories.should_receive(:cache).once
 
         index.index
       end
@@ -94,14 +95,14 @@ describe Picky::Index do
       @index = described_class.new :some_name do
         source the_source
       end
-      @index.define_category :some_category_name1
-      @index.define_category :some_category_name2
+      @index.category :some_category_name1
+      @index.category :some_category_name2
     end
-    describe 'define_source' do
+    describe 'source' do
       it 'can be set with this method' do
         source = stub :source, :each => [].each
 
-        @index.define_source source
+        @index.source source
 
         @index.source.should == source
       end
@@ -116,7 +117,7 @@ describe Picky::Index do
       end
       context 'with categories' do
         before(:each) do
-          @index.define_category :some_name, :source => stub(:source)
+          @index.category :some_name, :source => stub(:source)
         end
         it 'returns it if found' do
           @index[:some_name].should_not == nil

data/spec/lib/index_spec.rb

@@ -49,35 +49,35 @@ describe Picky::Index do
       end
     end
 
-    describe 'define_category' do
+    describe 'category' do
       context 'with block' do
         it 'returns the category' do
           expected = nil
-          api.define_category(:some_name){ |category| expected = category }.should == expected
+          api.category(:some_name){ |category| expected = category }.should == expected
         end
         it 'takes a string' do
-          lambda { api.define_category('some_name'){ |indexing, indexed| } }.should_not raise_error
+          lambda { api.category('some_name'){ |indexing, indexed| } }.should_not raise_error
         end
         it 'yields both the indexing category and the indexed category' do
-          api.define_category(:some_name) do |category|
+          api.category(:some_name) do |category|
             category.should be_kind_of(Picky::Category)
           end
         end
         it 'yields the category which has the given name' do
-          api.define_category(:some_name) do |category|
+          api.category(:some_name) do |category|
             category.name.should == :some_name
           end
         end
       end
       context 'without block' do
         it 'works' do
-          lambda { api.define_category(:some_name) }.should_not raise_error
+          lambda { api.category(:some_name) }.should_not raise_error
         end
         it 'takes a string' do
-          lambda { api.define_category('some_name') }.should_not raise_error
+          lambda { api.category('some_name') }.should_not raise_error
         end
         it 'returns itself' do
-          api.define_category(:some_name).should be_kind_of(Picky::Category)
+          api.category(:some_name).should be_kind_of(Picky::Category)
         end
       end
     end

data/spec/lib/indexers/base_spec.rb

@@ -23,21 +23,21 @@ describe Picky::Indexers::Base do
       indexer.stub! :process
 
       expect {
-        indexer.index []
+        indexer.prepare []
       }.to raise_error("Trying to index without a source for some_index_or_category.")
     end
   end
 
-  describe 'index' do
+  describe 'prepare' do
     before(:each) do
       some_index_or_category.should_receive(:source).any_number_of_times.and_return :some_source
     end
     it 'processes' do
       categories = stub :categories, :empty => nil, :cache => nil
 
-      indexer.should_receive(:process).once.with categories
+      indexer.should_receive(:process).once.with categories, anything
 
-      indexer.index categories
+      indexer.prepare categories
     end
     it 'calls the right methods on the categories' do
       indexer.stub! :process
@@ -45,9 +45,8 @@ describe Picky::Indexers::Base do
       categories = stub :categories
 
       categories.should_receive(:empty).once.ordered
-      categories.should_receive(:cache).once.ordered
 
-      indexer.index categories
+      indexer.prepare categories
     end
   end
 

data/spec/lib/indexers/parallel_spec.rb

@@ -5,24 +5,24 @@ describe Picky::Indexers::Parallel do
   before(:each) do
     @source     = stub :source
     @index      = stub :index, :name => :some_index, :source => @source
-    
+
     @categories = stub :categories
-    
+
     @indexer = described_class.new @index
     @indexer.stub! :timed_exclaim
   end
-  
+
   describe 'flush' do
     it 'flushes to joined cache to the file and clears it' do
       cache = stub :cache
       file  = stub :file
-      
-      cache.should_receive(:join).twice.and_return :joined
-      file.should_receive(:write).twice.with(:joined).and_return :joined
-      cache.should_receive(:clear).twice
-      
-      @indexer.flush [[nil, cache, file], [nil, cache, file]]
+
+      cache.should_receive(:join).once.and_return :joined
+      file.should_receive(:write).once.with(:joined).and_return :joined
+      cache.should_receive(:clear).once
+
+      @indexer.flush file, cache
     end
   end
-  
+
 end

data/spec/lib/indexes_indexed_spec.rb

@@ -48,14 +48,8 @@ describe Picky::Indexes do
         indexes.index_mapping.should == {}
       end
     end
-    describe 'reload' do
+    describe 'load' do
       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
 

data/spec/lib/indexes_indexing_spec.rb

@@ -19,12 +19,17 @@ describe Picky::Indexes do
       indexes.register @index1
       indexes.register @index2
     end
-    describe 'index_for_tests' 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
+    describe 'index' do
+      it 'prepares and caches each' do
+        scheduler = stub :scheduler, :fork? => false, :finish => nil
 
-        indexes.index_for_tests
+        @index1.should_receive(:prepare).once.with(scheduler).ordered
+        @index2.should_receive(:prepare).once.with(scheduler).ordered
+
+        @index1.should_receive(:cache).once.with(scheduler).ordered
+        @index2.should_receive(:cache).once.with(scheduler).ordered
+
+        indexes.index scheduler
       end
     end
     describe 'register' do

data/spec/lib/query/indexes_check_spec.rb

@@ -3,23 +3,52 @@ require 'spec_helper'
 describe Picky::Query::IndexesCheck do
 
   describe 'check_backend_types' do
-    before(:each) do
-      @redis  = stub :redis,  :backend => Picky::Backends::Redis.new
-      @memory = stub :memory, :backend => Picky::Backends::Memory.new
+    backends = [
+      Picky::Backends::Memory.new,
+      Picky::Backends::File.new,
+      Picky::Backends::SQLite.new,
+      Picky::Backends::Redis.new
+    ]
+    backends.each do |backend|
+      it 'does not raise on the same type' do
+        index = stub :index, backend: backend
+        described_class.check_backends [index, index]
+      end
     end
-    it 'does not raise on the same type' do
-      described_class.check_backend_types [@redis, @redis]
-    end
-    it 'raises on multiple types' do
-      expect do
-        described_class.check_backend_types [@redis, @memory]
-      end.to raise_error(Picky::Query::DifferentTypesError)
+
+    # Test all combinations
+    #
+    combinations = backends.combination 2
+    combinations.each do |backend1, backend2|
+      let(:index1) { stub :index1, backend: backend1 }
+      let(:index2) { stub :index2, backend: backend2 }
+      it 'raises on multiple types' do
+        expect do
+          described_class.check_backends [index1, index2]
+        end.to raise_error(Picky::Query::DifferentBackendsError)
+      end
+      it 'raises with the right message on multiple types' do
+        expect do
+          described_class.check_backends [index1, index2]
+        end.to raise_error("Currently it isn't possible to mix Indexes with backends #{index1.backend.class} and #{index2.backend.class} in the same Search instance.")
+      end
     end
-    it 'raises with the right message on multiple types' do
-      expect do
-        described_class.check_backend_types [@redis, @memory]
-      end.to raise_error("Currently it isn't possible to mix Indexes with backends Picky::Backends::Redis and Picky::Backends::Memory in the same Search instance.")
+    combinations = backends.combination 3
+    combinations.each do |backend1, backend2, backend3|
+      let(:index1) { stub :index1, backend: backend1 }
+      let(:index2) { stub :index2, backend: backend2 }
+      let(:index3) { stub :index2, backend: backend3 }
+      it 'raises on multiple types' do
+        expect do
+          described_class.check_backends [index1, index2, index3]
+        end.to raise_error(Picky::Query::DifferentBackendsError)
+      end
+      it 'raises with the right message on multiple types' do
+        expect do
+          described_class.check_backends [index1, index2, index3]
+        end.to raise_error("Currently it isn't possible to mix Indexes with backends #{index1.backend.class} and #{index2.backend.class} and #{index3.backend.class} in the same Search instance.")
+      end
     end
   end
-  
+
 end

data/spec/lib/query/indexes_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
 describe Picky::Query::Indexes do
-  
+
   before(:each) do
-    Picky::Query::IndexesCheck.stub! :check_backend_types
+    Picky::Query::IndexesCheck.stub! :check_backends
   end
-  
+
   3.times do |i|
     n       = i + 1
     name    = :"index#{n}"
@@ -19,7 +19,7 @@ describe Picky::Query::Indexes do
     indexes.send :initialize, index1, index2, index3
     indexes
   end
-  
+
   describe 'expand_combinations_from' do
     it 'generates all possible combinations from the given ones' do
       combinations = [[1,2,3], [:a, :b, :c], [:k, :l]]
@@ -47,22 +47,22 @@ describe Picky::Query::Indexes do
     end
     it 'can handle small combinations' do
       combinations = [[1], [2], [3]]
-      
+
       indexes.expand_combinations_from(combinations).should == [[1, 2, 3]]
     end
     it 'can handle empty combinations' do
       combinations = [[1,2,3], [:a, :b, :c], []]
-      
+
       indexes.expand_combinations_from(combinations).should == []
     end
     it 'can handle empty combinations' do
       combinations = [[], [:a, :b, :c], []]
-      
+
       indexes.expand_combinations_from(combinations).should == []
     end
     it 'can handle totally empty combinations' do
       combinations = [[], [], []]
-      
+
       indexes.expand_combinations_from(combinations).should == []
     end
     it 'is fast in a complicated case' do
@@ -86,7 +86,7 @@ describe Picky::Query::Indexes do
       performance_of { indexes.expand_combinations_from(combinations) }.should < 0.00045
     end
   end
-  
+
   describe 'prepared_allocations_for' do
     before(:each) do
       @allocations = stub :allocations
@@ -96,14 +96,14 @@ describe Picky::Query::Indexes do
       @allocations.should_receive(:uniq).once.ordered.with()
       @allocations.should_receive(:calculate_score).once.ordered.with(:some_weights)
       @allocations.should_receive(:sort!).once.ordered.with()
-      
+
       indexes.prepared_allocations_for :some_tokens, :some_weights
     end
     it 'calls the right method in order' do
       @allocations.should_receive(:uniq).once.ordered.with()
       @allocations.should_receive(:calculate_score).once.ordered.with({})
       @allocations.should_receive(:sort!).once.ordered.with()
-      
+
       indexes.prepared_allocations_for :some_tokens
     end
   end

data/spec/lib/query/token_spec.rb

@@ -407,6 +407,16 @@ describe Picky::Query::Token do
 
       token.instance_variable_get(:@partial).should be_nil
     end
+    it 'lets the last one win' do
+      token = described_class.processed 'text"*'
+
+      token.partial?.should == true
+    end
+    it 'lets the last one win' do
+      token = described_class.processed 'text*"'
+
+      token.partial?.should == false
+    end
   end
 
   describe "processed" do

data/spec/lib/{indexed/wrappers → results}/exact_first_spec.rb

@@ -1,22 +1,21 @@
 require 'spec_helper'
 
-describe Picky::Wrappers::Category::ExactFirst do
+describe Picky::Results::ExactFirst do
 
   before(:each) do
     @exact    = stub :exact
     @partial  = stub :partial
     @category = stub :category, :exact => @exact, :partial => @partial
-
-    @wrapper  = described_class.new @category
+    @category.extend described_class
   end
 
   describe "self.wrap" do
     context "index" do
       it "wraps each category" do
         index = Picky::Index.new :some_index
-        index.define_category :some_category
+        index.category :some_category
 
-        described_class.wrap index
+        index.extend described_class
 
         index.categories.categories.each do |category|
           category.should be_kind_of(described_class)
@@ -24,16 +23,14 @@ describe Picky::Wrappers::Category::ExactFirst do
       end
       it "returns the index" do
         index = Picky::Index.new :some_index
-        index.define_category :some_category
+        index.category :some_category
 
-        described_class.wrap(index).should == index
+        index.extend(described_class).should == index
       end
     end
     context "category" do
-      it "wraps each category" do
-        category = stub :category, :exact => :exact, :partial => :partial
-
-        described_class.wrap(category).should be_kind_of(described_class)
+      it "wraps the category" do
+        @category.should be_kind_of(described_class)
       end
     end
   end
@@ -43,13 +40,13 @@ describe Picky::Wrappers::Category::ExactFirst do
       @exact.stub!   :ids => [1,4,5,6]
       @partial.stub! :ids => [2,3,7]
 
-      @wrapper.ids(stub(:token, :text => :anything, :partial? => true)).should == [1,4,5,6,2,3,7]
+      @category.ids(stub(:token, :text => :anything, :partial? => true)).should == [1,4,5,6,2,3,7]
     end
     it "uses only the exact ids" do
       @exact.stub!   :ids => [1,4,5,6]
       @partial.stub! :ids => [2,3,7]
 
-      @wrapper.ids(stub(:token, :text => :anything, :partial? => false)).should == [1,4,5,6]
+      @category.ids(stub(:token, :text => :anything, :partial? => false)).should == [1,4,5,6]
     end
   end
 
@@ -63,10 +60,10 @@ describe Picky::Wrappers::Category::ExactFirst do
           @partial.stub! :weight => 1.23
         end
         it "uses the higher weight" do
-          @wrapper.weight(stub(:token, :text => :anything, :partial? => true)).should == 1.23
+          @category.weight(stub(:token, :text => :anything, :partial? => true)).should == 1.23
         end
         it "uses the exact weight" do
-          @wrapper.weight(stub(:token, :text => :anything, :partial? => false)).should == 0.12
+          @category.weight(stub(:token, :text => :anything, :partial? => false)).should == 0.12
         end
       end
       context "partial without weight" do
@@ -74,10 +71,10 @@ describe Picky::Wrappers::Category::ExactFirst do
           @partial.stub! :weight => nil
         end
         it "uses the exact weight" do
-          @wrapper.weight(stub(:token, :text => :anything, :partial? => true)).should == 0.12
+          @category.weight(stub(:token, :text => :anything, :partial? => true)).should == 0.12
         end
         it "uses the exact weight" do
-          @wrapper.weight(stub(:token, :text => :anything, :partial? => false)).should == 0.12
+          @category.weight(stub(:token, :text => :anything, :partial? => false)).should == 0.12
         end
       end
     end
@@ -90,10 +87,10 @@ describe Picky::Wrappers::Category::ExactFirst do
           @partial.stub! :weight => 0.12
         end
         it "uses the partial weight" do
-          @wrapper.weight(stub(:token, :text => :anything, :partial? => true)).should == 0.12
+          @category.weight(stub(:token, :text => :anything, :partial? => true)).should == 0.12
         end
         it "uses the exact weight" do
-          @wrapper.weight(stub(:token, :text => :anything, :partial? => false)).should == nil
+          @category.weight(stub(:token, :text => :anything, :partial? => false)).should == nil
         end
       end
       context "partial without weight" do
@@ -101,10 +98,10 @@ describe Picky::Wrappers::Category::ExactFirst do
           @partial.stub! :weight => nil
         end
         it "is nil" do
-          @wrapper.weight(stub(:token, :text => :anything, :partial? => true)).should == nil
+          @category.weight(stub(:token, :text => :anything, :partial? => true)).should == nil
         end
         it "is nil" do
-          @wrapper.weight(stub(:token, :text => :anything, :partial? => false)).should == nil
+          @category.weight(stub(:token, :text => :anything, :partial? => false)).should == nil
         end
       end
     end

data/spec/lib/scheduler_spec.rb

@@ -0,0 +1,92 @@
+# encoding: utf-8
+require 'spec_helper'
+
+describe Picky::Scheduler do
+
+  context 'default params' do
+    let(:scheduler) { described_class.new }
+
+    context 'without forking' do
+      before(:each) do
+        scheduler.stub! :fork? => false
+      end
+      context 'non-stubbed forking' do
+        it 'works correctly' do
+          scheduler.schedule { sleep 0.01 }
+          scheduler.schedule { sleep 0.01 }
+          scheduler.schedule { sleep 0.01 }
+          scheduler.schedule { sleep 0.01 }
+        end
+        it 'works correctly' do
+          called = 0
+
+          scheduler.schedule { called += 1 }
+          scheduler.schedule { called += 1 }
+          scheduler.schedule { called += 1 }
+          scheduler.schedule { called += 1 }
+
+          called.should == 4
+        end
+      end
+    end
+
+    describe 'fork?' do
+      context 'OS can fork' do
+        it 'returns false' do
+          scheduler.fork?.should be_false
+        end
+      end
+      context 'OS cannot fork' do
+        before(:each) do
+          Process.stub! :fork => nil
+        end
+        it 'returns false' do
+          scheduler.fork?.should be_false
+        end
+      end
+    end
+  end
+  context 'default params' do
+    let(:scheduler) { described_class.new parallel: true }
+
+    context 'stubbed forking' do
+      it 'works correctly' do
+        scheduler.scheduler.should_receive(:schedule).exactly(4).times.and_yield
+
+        scheduler.schedule { sleep 0.01 }
+        scheduler.schedule { sleep 0.01 }
+        scheduler.schedule { sleep 0.01 }
+        scheduler.schedule { sleep 0.01 }
+      end
+      it 'works correctly' do
+        scheduler.scheduler.should_receive(:schedule).any_number_of_times.and_yield
+
+        called = 0
+
+        scheduler.schedule { called += 1 }
+        scheduler.schedule { called += 1 }
+        scheduler.schedule { called += 1 }
+        scheduler.schedule { called += 1 }
+
+        called.should == 4
+      end
+    end
+
+    describe 'fork?' do
+      context 'OS can fork' do
+        it 'returns true' do
+          scheduler.fork?.should == true
+        end
+      end
+      # context 'OS cannot fork' do
+      #   before(:each) do
+      #     Process.send :undef, :fork
+      #   end
+      #   it 'returns false' do
+      #     scheduler.fork?.should == false
+      #   end
+      # end
+    end
+  end
+
+end