picky 1.4.1 → 1.4.2

data/spec/lib/query/indexes_spec.rb

@@ -0,0 +1,81 @@
+require 'spec_helper'
+
+describe Internals::Query::Indexes do
+
+  3.times do |i|
+    n       = i + 1
+    name    = :"index#{n}"
+    indexed = :"indexed#{n}"
+    let(name) { stub name, :indexed => stub(indexed) }
+  end
+
+  let(:indexes) { described_class.new index1, index2, index3 }
+  
+  describe 'expand_combinations_from' do
+    it 'generates all possible combinations from the given ones' do
+      combinations = [[1,2,3], [:a, :b, :c], [:k, :l]]
+
+      indexes.expand_combinations_from(combinations).should == [
+        [1, :a, :k],
+        [1, :a, :l],
+        [1, :b, :k],
+        [1, :b, :l],
+        [1, :c, :k],
+        [1, :c, :l],
+        [2, :a, :k],
+        [2, :a, :l],
+        [2, :b, :k],
+        [2, :b, :l],
+        [2, :c, :k],
+        [2, :c, :l],
+        [3, :a, :k],
+        [3, :a, :l],
+        [3, :b, :k],
+        [3, :b, :l],
+        [3, :c, :k],
+        [3, :c, :l]
+      ]
+    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 == nil
+    end
+    it 'can handle empty combinations' do
+      combinations = [[], [:a, :b, :c], []]
+      
+      indexes.expand_combinations_from(combinations).should == nil
+    end
+    it 'can handle totally empty combinations' do
+      combinations = [[], [], []]
+      
+      indexes.expand_combinations_from(combinations).should == nil
+    end
+    it 'is fast in a complicated case' do
+      combinations = [[1,2,3], [:a, :b, :c], [:k, :l]]
+
+      performance_of { indexes.expand_combinations_from(combinations) }.should < 0.00055
+    end
+    it 'is fast in a simple case' do
+      combinations = [[1], [2], [3]]
+
+      performance_of { indexes.expand_combinations_from(combinations) }.should < 0.00055
+    end
+    it 'is very fast in a 1-empty case' do
+      combinations = [[], [2], [3]]
+
+      performance_of { indexes.expand_combinations_from(combinations) }.should < 0.00045
+    end
+    it 'is very fast in a all-empty case' do
+      combinations = [[], [], []]
+
+      performance_of { indexes.expand_combinations_from(combinations) }.should < 0.00045
+    end
+  end
+
+end

data/spec/lib/query/live_spec.rb

@@ -9,16 +9,16 @@ describe Query::Live do
 
   describe 'result_type' do
     before(:each) do
-      @query = Query::Live.new @index
+      @query = described_class.new @index
     end
     it "should return a specific type" do
-      @query.result_type.should == Results::Live
+      @query.result_type.should == Internals::Results::Live
     end
   end
 
   describe "execute" do
     before(:each) do
-      @query = Query::Live.new @index
+      @query = described_class.new @index
     end
     it "should get allocations" do
       @query.result_type.should_receive :from

data/spec/lib/query/qualifiers_spec.rb

@@ -1,17 +1,17 @@
 require 'spec_helper'
 
-describe Query::Qualifiers do
+describe Internals::Query::Qualifiers do
   
   before(:each) do
-    Query::Qualifiers.instance << Query::Qualifier.new(:test1, ['t1', 'tt1', 'ttt1'])
-    Query::Qualifiers.instance << Query::Qualifier.new(:test2, [:t2, :tt2, :ttt2])
-    Query::Qualifiers.instance << Query::Qualifier.new(:test3, [:t3, :tt3, :ttt3])
-    Query::Qualifiers.instance.prepare
+    described_class.instance << Internals::Query::Qualifier.new(:test1, ['t1', 'tt1', 'ttt1'])
+    described_class.instance << Internals::Query::Qualifier.new(:test2, [:t2, :tt2, :ttt2])
+    described_class.instance << Internals::Query::Qualifier.new(:test3, [:t3, :tt3, :ttt3])
+    described_class.instance.prepare
   end
   
   def self.it_should_normalize(qualifier, expected)
     it "should map #{qualifier} to #{expected}" do
-      Query::Qualifiers.instance.normalize(qualifier).should == expected
+      described_class.instance.normalize(qualifier).should == expected
     end
   end
 

data/spec/lib/query/token_spec.rb

@@ -1,11 +1,11 @@
 # coding: utf-8
 require 'spec_helper'
 
-describe Query::Token do
+describe Internals::Query::Token do
   
   before(:all) do
-    Query::Qualifiers.instance << Query::Qualifier.new(:specific, [:sp, :spec])
-    Query::Qualifiers.instance.prepare
+    Internals::Query::Qualifiers.instance << Internals::Query::Qualifier.new(:specific, [:sp, :spec])
+    Internals::Query::Qualifiers.instance.prepare
   end
   
   describe 'next_similar_token' do
@@ -13,7 +13,7 @@ describe Query::Token do
       @bundle   = stub :bundle, :similar => [:array, :of, :similar]
       @category = stub :category, :bundle_for => @bundle
       
-      @token = Query::Token.processed 'similar~'
+      @token = described_class.processed 'similar~'
     end
     it 'returns the right next tokens' do
       next_token = @token.next_similar_token @category
@@ -36,7 +36,7 @@ describe Query::Token do
         before(:each) do
           @bundle.stub! :similar => [:array, :of, :similar]
 
-          @token = Query::Token.processed 'similar~'
+          @token = described_class.processed 'similar~'
         end
         it 'should have a certain original text' do
           @token.next_similar @bundle
@@ -50,7 +50,7 @@ describe Query::Token do
         before(:each) do
           @bundle.stub! :similar => [:array, :of, :similar]
 
-          @token = Query::Token.processed 'similar~'
+          @token = described_class.processed 'similar~'
         end
         it 'generates all similar' do
           @token.next_similar(@bundle).should == :array
@@ -73,7 +73,7 @@ describe Query::Token do
         before(:each) do
           @bundle.stub! :similar => [:array, :of, :similar]
 
-          @token = Query::Token.processed 'nonsimilar'
+          @token = described_class.processed 'nonsimilar'
         end
         it 'generates all similar' do
           @token.next_similar(@bundle).should == nil
@@ -93,7 +93,7 @@ describe Query::Token do
     before(:each) do
       @bundle = stub :bundle
       
-      @token = Query::Token.processed 'flarb~'
+      @token = described_class.processed 'flarb~'
     end
     context "with similar" do
       before(:each) do
@@ -116,7 +116,7 @@ describe Query::Token do
   describe 'to_solr' do
     def self.it_should_solr text, expected_result
       it "should solrify into #{expected_result} from #{text}" do
-        Query::Token.processed(text).to_solr.should == expected_result
+        described_class.processed(text).to_solr.should == expected_result
       end
     end
     it_should_solr 's',            's'
@@ -144,7 +144,7 @@ describe Query::Token do
   describe 'qualify' do
     def self.it_should_qualify text, expected_result
       it "should extract the qualifier #{expected_result} from #{text}" do
-        Query::Token.new(text).qualify.should == expected_result
+        described_class.new(text).qualify.should == expected_result
       end
     end
     it_should_qualify 'spec:qualifier',    :specific
@@ -159,7 +159,7 @@ describe Query::Token do
   describe 'processed' do
     it 'should have an order' do
       token = stub :token
-      Query::Token.should_receive(:new).once.and_return token
+      described_class.should_receive(:new).once.and_return token
 
       token.should_receive(:qualify).once.ordered
       token.should_receive(:extract_original).once.ordered
@@ -167,17 +167,17 @@ describe Query::Token do
       token.should_receive(:similarize).once.ordered
       token.should_receive(:remove_illegals).once.ordered
 
-      Query::Token.processed :any_text
+      described_class.processed :any_text
     end
     it 'should return a new token' do
-      Query::Token.processed('some text').should be_kind_of(Query::Token)
+      described_class.processed('some text').should be_kind_of(described_class)
     end
   end
 
   describe 'partial?' do
     context 'similar, partial' do
       before(:each) do
-        @token = Query::Token.processed 'similar~'
+        @token = described_class.processed 'similar~'
         @token.partial = true
       end
       it 'should be false' do
@@ -186,7 +186,7 @@ describe Query::Token do
     end
     context 'similar, not partial' do
       before(:each) do
-        @token = Query::Token.processed 'similar~'
+        @token = described_class.processed 'similar~'
       end
       it 'should be false' do
         @token.partial?.should == false
@@ -194,7 +194,7 @@ describe Query::Token do
     end
     context 'not similar, partial' do
       before(:each) do
-        @token = Query::Token.processed 'not similar'
+        @token = described_class.processed 'not similar'
         @token.partial = true
       end
       it 'should be true' do
@@ -203,7 +203,7 @@ describe Query::Token do
     end
     context 'not similar, not partial' do
       before(:each) do
-        @token = Query::Token.processed 'not similar'
+        @token = described_class.processed 'not similar'
       end
       it 'should be nil' do
         @token.partial?.should == nil
@@ -213,12 +213,12 @@ describe Query::Token do
 
   describe 'similar' do
     it 'should not change the original with the text' do
-      token = Query::Token.processed "bla~"
+      token = described_class.processed "bla~"
       token.text.should_not == token.original
     end
     def self.it_should_have_similarity text, expected_similarity_value
       it "should have #{ "no" unless expected_similarity_value } similarity for '#{text}'" do
-        Query::Token.processed(text).similar?.should == expected_similarity_value
+        described_class.processed(text).similar?.should == expected_similarity_value
       end
     end
     it_should_have_similarity 'name:',      nil
@@ -238,7 +238,7 @@ describe Query::Token do
 
   describe 'special cases' do
     it 'should be blank on ""' do
-      token = Query::Token.processed '""'
+      token = described_class.processed '""'
 
       token.should be_blank
     end
@@ -247,7 +247,7 @@ describe Query::Token do
   describe 'split' do
     def self.it_should_split text, expected_qualifier
       it "should extract #{expected_qualifier} from #{text}" do
-        Query::Token.new('any').send(:split, text).should == expected_qualifier
+        described_class.new('any').send(:split, text).should == expected_qualifier
       end
     end
     it_should_split '""',         [nil, '""']
@@ -261,7 +261,7 @@ describe Query::Token do
 
   describe "original" do
     it "should keep the original text even when processed" do
-      token = Query::Token.processed "I'm the original token text."
+      token = described_class.processed "I'm the original token text."
 
       token.original.should == "I'm the original token text."
     end
@@ -269,12 +269,12 @@ describe Query::Token do
 
   describe "blank?" do
     it "should be blank if the token text itself is blank" do
-      token = Query::Token.processed ''
+      token = described_class.processed ''
 
       token.blank?.should be_true
     end
     it "should be non-blank if the token text itself is non-blank" do
-      token = Query::Token.processed 'not empty'
+      token = described_class.processed 'not empty'
 
       token.blank?.should be_false
     end
@@ -283,14 +283,14 @@ describe Query::Token do
   describe "to_s" do
     describe "with qualifier" do
       it "should display qualifier and text combined with a ':'" do
-        token = Query::Token.processed('sp:qualifier')
+        token = described_class.processed('sp:qualifier')
 
         token.to_s.should == 'specific:qualifier'
       end
     end
     describe "without qualifier" do
       it "should display just the text" do
-        token = Query::Token.processed('text')
+        token = described_class.processed('text')
 
         token.to_s.should == 'text'
       end
@@ -300,7 +300,7 @@ describe Query::Token do
   describe 'user_defined_category_name' do
     context 'with qualifier' do
       before(:each) do
-        @token = Query::Token.processed('sp:qualifier')
+        @token = described_class.processed('sp:qualifier')
       end
       it 'should return the qualifier' do
         @token.user_defined_category_name.should == :specific
@@ -308,7 +308,7 @@ describe Query::Token do
     end
     context 'without qualifier' do
       before(:each) do
-        @token = Query::Token.processed('noqualifier')
+        @token = described_class.processed('noqualifier')
       end
       it 'should return nil' do
         @token.user_defined_category_name.should == nil
@@ -319,7 +319,7 @@ describe Query::Token do
   describe "split" do
     def self.it_should_split text, expected_result
       it "should split #{expected_result} from #{text}" do
-        Query::Token.new('any').send(:split, text).should == expected_result
+        described_class.new('any').send(:split, text).should == expected_result
       end
     end
     it_should_split ':',                 [nil,        '']
@@ -335,7 +335,7 @@ describe Query::Token do
   describe 'partial=' do
     context 'partial nil' do
       before(:each) do
-        @token = Query::Token.new 'text'
+        @token = described_class.new 'text'
       end
       it 'should set partial' do
         @token.partial = true
@@ -350,7 +350,7 @@ describe Query::Token do
     end
     context 'partial not nil' do
       before(:each) do
-        @token = Query::Token.processed 'text*'
+        @token = described_class.processed 'text*'
       end
       it 'should not set partial' do
         @token.partial = false
@@ -362,17 +362,17 @@ describe Query::Token do
 
   describe 'partialize!' do
     it 'should not partialize a token if the text ends with "' do
-      token = Query::Token.processed 'text"'
+      token = described_class.processed 'text"'
 
       token.instance_variable_get(:@partial).should be_false
     end
     it 'should partialize a token if the text ends with *' do
-      token = Query::Token.processed 'text*'
+      token = described_class.processed 'text*'
 
       token.instance_variable_get(:@partial).should be_true
     end
     it 'should not partialize a token if the text ends with ~' do
-      token = Query::Token.processed 'text~'
+      token = described_class.processed 'text~'
 
       token.instance_variable_get(:@partial).should be_nil
     end
@@ -380,22 +380,22 @@ describe Query::Token do
 
   describe "processed" do
     it 'should remove *' do
-      token = Query::Token.processed 'text*'
+      token = described_class.processed 'text*'
 
       token.text.should == 'text'
     end
     it 'should remove ~' do
-      token = Query::Token.processed 'text~'
+      token = described_class.processed 'text~'
 
       token.text.should == 'text'
     end
     it 'should remove "' do
-      token = Query::Token.processed 'text"'
+      token = described_class.processed 'text"'
 
       token.text.should == 'text'
     end
     it "should pass on a processed text" do
-      Query::Token.processed('text').text.should == 'text'
+      described_class.processed('text').text.should == 'text'
     end
   end
 

data/spec/lib/query/tokens_spec.rb

@@ -1,21 +1,21 @@
 require 'spec_helper'
 
-describe Query::Tokens do
+describe Internals::Query::Tokens do
   
   before(:all) do
-    Query::Qualifiers.instance << Query::Qualifier.new(:specific, [:sp, :spec])
-    Query::Qualifiers.instance.prepare
+    Internals::Query::Qualifiers.instance << Internals::Query::Qualifier.new(:specific, [:sp, :spec])
+    Internals::Query::Qualifiers.instance.prepare
   end
   
   describe 'to_solr_query' do
     context 'many tokens' do
       before(:each) do
-        @tokens = Query::Tokens.new [
-          Query::Token.processed('this~'),
-          Query::Token.processed('is'),
-          Query::Token.processed('a'),
-          Query::Token.processed('sp:solr'),
-          Query::Token.processed('query"')
+        @tokens = described_class.new [
+          Internals::Query::Token.processed('this~'),
+          Internals::Query::Token.processed('is'),
+          Internals::Query::Token.processed('a'),
+          Internals::Query::Token.processed('sp:solr'),
+          Internals::Query::Token.processed('query"')
         ]
       end
       it 'should output a correct solr query' do
@@ -28,7 +28,7 @@ describe Query::Tokens do
     before(:each) do
       @blank    = stub :blank, :blank? => true
       @nonblank = stub :nonblank, :blank? => false
-      @tokens = Query::Tokens.new [@blank, @nonblank, @blank, @blank, @nonblank]
+      @tokens = described_class.new [@blank, @nonblank, @blank, @blank, @nonblank]
     end
     it 'should not cut it down' do
       @tokens.reject
@@ -40,8 +40,8 @@ describe Query::Tokens do
   describe 'cap' do
     context 'one token' do
       before(:each) do
-        @token = Query::Token.processed 'Token'
-        @tokens = Query::Tokens.new [@token]
+        @token = Internals::Query::Token.processed 'Token'
+        @tokens = described_class.new [@token]
       end
       it 'does not cut it down' do
         @tokens.cap 5
@@ -56,15 +56,15 @@ describe Query::Tokens do
     end
     context 'many tokens' do
       before(:each) do
-        @first = Query::Token.processed 'Hello'
-        @second = Query::Token.processed 'I'
-        @third = Query::Token.processed 'Am'
-        @tokens = Query::Tokens.new [
+        @first = Internals::Query::Token.processed 'Hello'
+        @second = Internals::Query::Token.processed 'I'
+        @third = Internals::Query::Token.processed 'Am'
+        @tokens = Internals::Query::Tokens.new [
           @first,
           @second,
           @third,
-          Query::Token.processed('A'),
-          Query::Token.processed('Token')
+          Internals::Query::Token.processed('A'),
+          Internals::Query::Token.processed('Token')
         ]
       end
       it 'should cap the number of tokens' do
@@ -78,8 +78,8 @@ describe Query::Tokens do
   describe 'partialize_last' do
     context 'special case' do
       before(:each) do
-        @token = Query::Token.processed 'a*'
-        @tokens = Query::Tokens.new [@token]
+        @token = Internals::Query::Token.processed 'a*'
+        @tokens = described_class.new [@token]
       end
       it 'should have a last partialized token' do
         @token.should be_partial
@@ -92,8 +92,8 @@ describe Query::Tokens do
     end
     context 'one token' do
       before(:each) do
-        @token = Query::Token.processed 'Token'
-        @tokens = Query::Tokens.new [@token]
+        @token = Internals::Query::Token.processed 'Token'
+        @tokens = described_class.new [@token]
       end
       it 'should not have a last partialized token' do
         @token.should_not be_partial
@@ -106,13 +106,13 @@ describe Query::Tokens do
     end
     context 'many tokens' do
       before(:each) do
-        @first = Query::Token.processed 'Hello'
-        @last = Query::Token.processed 'Token'
-        @tokens = Query::Tokens.new [
+        @first  = Internals::Query::Token.processed 'Hello'
+        @last   = Internals::Query::Token.processed 'Token'
+        @tokens = described_class.new [
           @first,
-          Query::Token.processed('I'),
-          Query::Token.processed('Am'),
-          Query::Token.processed('A'),
+          Internals::Query::Token.processed('I'),
+          Internals::Query::Token.processed('Am'),
+          Internals::Query::Token.processed('A'),
           @last
         ]
       end
@@ -134,12 +134,12 @@ describe Query::Tokens do
 
   describe 'to_s' do
     before(:each) do
-      @tokens = Query::Tokens.new [
-        Query::Token.processed('Hello~'),
-        Query::Token.processed('I~'),
-        Query::Token.processed('Am'),
-        Query::Token.processed('A*'),
-        Query::Token.processed('Token~')
+      @tokens = described_class.new [
+        Internals::Query::Token.processed('Hello~'),
+        Internals::Query::Token.processed('I~'),
+        Internals::Query::Token.processed('Am'),
+        Internals::Query::Token.processed('A*'),
+        Internals::Query::Token.processed('Token~')
       ]
     end
     it 'should work correctly' do
@@ -151,7 +151,7 @@ describe Query::Tokens do
     describe name do
       before(:each) do
         @internal_tokens = mock :internal_tokens
-        @tokens = Query::Tokens.new @internal_tokens
+        @tokens = described_class.new @internal_tokens
       end
       it "should delegate #{name} to the internal tokens" do
         proc_stub = lambda {}

data/spec/lib/sources/db_spec.rb

@@ -10,7 +10,7 @@ describe Sources::DB do
     
     @select_statement = stub :statement
     
-    @source = Sources::DB.new @select_statement, :option => :some_options
+    @source = described_class.new @select_statement, :option => :some_options
     
     @source.stub! :database => @adapter
     @source.stub! :connect_backend
@@ -21,27 +21,32 @@ describe Sources::DB do
       @type     = stub :type,     :name => :some_type
       @category = stub :category, :from => :some_category
     end
-    context 'no data' do
-      it "delegates to the connection" do
+    context 'mysql' do
+      before(:each) do
+        @connection.stub! :adapter_name => 'mysql'
+      end
+      context 'no data' do
+        it "delegates to the connection" do
 
-        @connection.should_receive(:execute).
-                    once.
-                    with('SELECT indexed_id, some_category FROM some_type_type_index st WHERE st.id > some_offset LIMIT 25000').
-                    and_return []
+          @connection.should_receive(:execute).
+                      once.
+                      with('SELECT indexed_id, some_category FROM some_type_type_index st WHERE st.id > some_offset LIMIT 25000').
+                      and_return []
 
-        @source.get_data @type, @category, :some_offset
+          @source.get_data @type, @category, :some_offset
+        end
       end
-    end
-    context 'with data' do
-      it 'yields to the caller' do
-        @connection.should_receive(:execute).
-                    any_number_of_times.
-                    with('SELECT indexed_id, some_category FROM some_type_type_index st WHERE st.id > some_offset LIMIT 25000').
-                    and_return [[1, 'text']]
+      context 'with data' do
+        it 'yields to the caller' do
+          @connection.should_receive(:execute).
+                      any_number_of_times.
+                      with('SELECT indexed_id, some_category FROM some_type_type_index st WHERE st.id > some_offset LIMIT 25000').
+                      and_return [[1, 'text']]
 
-        @source.get_data @type, @category, :some_offset do |id, text|
-          id.should == 1
-          text.should == 'text'
+          @source.get_data @type, @category, :some_offset do |id, text|
+            id.should == 1
+            text.should == 'text'
+          end
         end
       end
     end