picky 4.0.0pre1 → 4.0.0pre2

data/spec/lib/query/token_spec.rb

@@ -12,105 +12,40 @@ describe Picky::Query::Token do
     end
   end
 
-  describe 'next_similar_token' do
-    before(:each) do
-      @bundle   = stub :bundle, :similar => [:array, :of, :similar]
-      @category = stub :category, :bundle_for => @bundle
-
-      @token = described_class.processed 'similar~', 'Similar~'
-    end
-    it 'returns the right next tokens' do
-      next_token = @token.next_similar_token @category
-      next_token.text.should == :array
-      next_token = next_token.next_similar_token @category
-      next_token.text.should == :of
-      next_token = next_token.next_similar_token @category
-      next_token.text.should == :similar
-      next_token = next_token.next_similar_token @category
-      next_token.should == nil
-    end
-  end
-
-  describe 'next_similar' do
-    before(:each) do
-      @bundle = stub :bundle
-    end
-    describe 'original' do
-      context 'with stub' do
-        before(:each) do
-          @bundle.stub! :similar => [:array, :of, :similar]
-
-          @token = described_class.processed 'similar~', 'Similar'
-        end
-        it 'should have a certain original text' do
-          @token.next_similar @bundle
-
-          @token.original.should == :array
-        end
+  describe 'similar_tokens_for' do
+    let(:token) { described_class.processed 'similar~', 'Similar~' }
+    context 'with similar' do
+      before(:each) do
+        @bundle   = stub :bundle, :similar => ['array', 'of', 'similar']
+        @category = stub :category, :bundle_for => @bundle
       end
-    end
-    context 'similar' do
-      context 'with stub' do
-        before(:each) do
-          @bundle.stub! :similar => [:array, :of, :similar]
-
-          @token = described_class.processed 'similar~', 'Similar'
-        end
-        it 'generates all similar' do
-          @token.next_similar(@bundle).should == :array
-          @token.next_similar(@bundle).should == :of
-          @token.next_similar(@bundle).should == :similar
-          @token.next_similar(@bundle).should == nil
-        end
-        it 'should have a certain text' do
-          @token.next_similar @bundle
-          @token.next_similar @bundle
-          @token.next_similar @bundle
-          @token.next_similar @bundle
-
-          @token.text.should == :similar
+      it 'returns a list of tokens' do
+        token.similar_tokens_for(@category).each do |token|
+          token.should be_kind_of(described_class)
         end
       end
-    end
-    context 'non-similar' do
-      context 'with stub' do
-        before(:each) do
-          @bundle.stub! :similar => [:array, :of, :similar]
-
-          @token = described_class.processed 'nonsimilar', 'Nonsimilar'
-        end
-        it 'generates all similar' do
-          @token.next_similar(@bundle).should == nil
-        end
-        it 'should have a certain text' do
-          @token.next_similar @bundle
-
-          @token.text.should == 'nonsimilar'
+      it 'returns all non-similar tokens' do
+        token.similar_tokens_for(@category).each do |token|
+          token.should_not be_similar
         end
       end
-    end
-  end
-
-  describe "generate_similarity_for" do
-    before(:each) do
-      @bundle = stub :bundle
-
-      @token = described_class.processed 'flarb~', 'FLARB~'
-    end
-    context "with similar" do
-      before(:each) do
-        @bundle.stub! :similar => [:array, :of, :similar]
+      it 'returns a list of tokens with the right text' do
+        token.similar_tokens_for(@category).map(&:text).should == ['array', 'of', 'similar']
+      end
+      it 'returns a list of tokens with the right original' do
+        token.similar_tokens_for(@category).map(&:original).should == ['array', 'of', 'similar']
       end
-      it "returns an array of the right size" do
-        @token.generate_similarity_for(@bundle).size.should == 3
+      it 'returns a list of tokens with the right categorization' do
+        token.similar_tokens_for(@category).map(&:user_defined_categories).should == [[@category], [@category], [@category]]
       end
     end
-    context "without similar" do
+    context 'without similar' do
       before(:each) do
-        @bundle.stub! :similar => []
+        @bundle   = stub :bundle, :similar => []
+        @category = stub :category, :bundle_for => @bundle
       end
-      it "returns an array of the right size" do
-        @token.generate_similarity_for(@bundle).size.should == 0
+      it 'returns an empty list' do
+        token.similar_tokens_for(@category).should == []
       end
     end
   end
@@ -167,12 +102,24 @@ describe Picky::Query::Token do
     it_should_qualify 'a,b,c:d',           [['a','b','c'], 'd']
     it_should_qualify ':',                 [nil,           '']
     it_should_qualify 'vorname:qualifier', [['vorname'],   'qualifier']
-    it_should_qualify 'with:qualifier',    [['with'],      'qualifier']
-    it_should_qualify 'without qualifier', [nil,           'without qualifier']
-    it_should_qualify 'name:',             [nil,           'name']
-    it_should_qualify ':broken qualifier', [[],            'broken qualifier']
-    it_should_qualify '',                  [nil,           '']
-    it_should_qualify 'fn:text',           [['fn'],        'text']
+  end
+
+  describe 'qualifier' do
+    it 'returns the right thing' do
+      token = described_class.processed 'b'
+
+      token.qualifiers.should == []
+    end
+    it 'returns the right thing' do
+      token = described_class.processed 'a:b'
+
+      token.qualifiers.should == ['a']
+    end
+    it 'returns the right thing' do
+      token = described_class.processed 'a,b:c'
+
+      token.qualifiers.should == ['a', 'b']
+    end
   end
 
   describe 'processed' do
@@ -199,6 +146,76 @@ describe Picky::Query::Token do
     end
   end
 
+  describe 'partialize' do
+    context 'token explicitly partial' do
+      let(:token) { described_class.new 'a*' }
+      it 'is afterwards partial' do
+        token.partialize
+
+        token.should be_partial
+      end
+    end
+    context 'token explicitly nonpartial' do
+      let(:token) { described_class.new 'a"' }
+      it 'is afterwards not partial' do
+        token.partialize
+
+        token.should_not be_partial
+      end
+    end
+    context 'token nonpartial' do
+      let(:token) { described_class.new 'a' }
+      it 'is afterwards not partial' do
+        token.partialize
+
+        token.should_not be_partial
+      end
+    end
+    context 'special case' do
+      let(:token) { described_class.new 'a*"' }
+      it 'is afterwards not partial - last one wins' do
+        token.partialize
+
+        token.should_not be_partial
+      end
+    end
+    context 'special case' do
+      let(:token) { described_class.new 'a"*' }
+      it 'is afterwards partial - last one wins' do
+        token.partialize
+
+        token.should be_partial
+      end
+    end
+  end
+
+  describe 'similarize' do
+    context 'token explicitly similar' do
+      let(:token) { described_class.new 'a~' }
+      it 'is afterwards similar' do
+        token.similarize
+
+        token.should be_similar
+      end
+    end
+    context 'token explicitly nonsimilar' do
+      let(:token) { described_class.new 'a"' }
+      it 'is afterwards not similar' do
+        token.similarize
+
+        token.should_not be_similar
+      end
+    end
+    context 'token nonsimilar' do
+      let(:token) { described_class.new 'a' }
+      it 'is afterwards not similar' do
+        token.similarize
+
+        token.should_not be_similar
+      end
+    end
+  end
+
   describe 'symbolize!' do
     before(:each) do
       @token = described_class.processed 'string', 'String'
@@ -323,70 +340,66 @@ describe Picky::Query::Token do
 
   describe 'qualifiers' do
     context 'with qualifier' do
-      before(:each) do
-        @token = described_class.processed('sp:qualifier')
-      end
+      let(:token) { described_class.processed 'sp:qualifier' }
       it 'should return the qualifier' do
-        @token.qualifiers.should == ['sp']
+        token.qualifiers.should == ['sp']
       end
     end
     context 'with incorrect qualifier' do
-      before(:each) do
-        @token = described_class.processed('specific:qualifier')
-      end
+      let(:token) { described_class.processed 'specific:qualifier' }
       it 'should return the qualifier' do
-        @token.qualifiers.should == ['specific']
+        token.qualifiers.should == ['specific']
       end
     end
     context 'with multiple qualifiers' do
-      before(:each) do
-        @token = described_class.processed('sp,spec:qualifier')
-      end
+      let(:token) { described_class.processed 'sp,spec:qualifier' }
       it 'should return the qualifier' do
-        @token.qualifiers.should == ['sp', 'spec']
+        token.qualifiers.should == ['sp', 'spec']
       end
     end
     context 'without qualifier' do
-      before(:each) do
-        @token = described_class.processed('noqualifier')
-      end
-      it 'should return nil' do
-        @token.qualifiers.should == nil
+      let(:token) { described_class.processed 'noqualifier' }
+      it 'is correct' do
+        token.qualifiers.should == []
       end
     end
   end
 
   describe 'partial=' do
     context 'partial nil' do
-      before(:each) do
-        @token = described_class.new 'text'
-      end
+      let(:token) { described_class.new 'text' }
       it 'should set partial' do
-        @token.partial = true
+        token.partial = true
 
-        @token.instance_variable_get(:@partial).should be_true
+        token.should be_partial
       end
       it 'should set partial' do
-        @token.partial = false
+        token.partial = false
 
-        @token.instance_variable_get(:@partial).should be_false
+        token.should_not be_partial
       end
     end
     context 'partial not nil' do
-      before(:each) do
-        @token = described_class.processed 'text*'
+      let(:token) { described_class.processed 'text"' }
+      it 'should not set partial' do
+        token.partial = true
+
+        token.should_not be_partial
       end
+    end
+    context 'partial not nil' do
+      let(:token) { described_class.processed 'text*' }
       it 'should not set partial' do
-        @token.instance_variable_set :@partial, false
+        token.instance_variable_set :@partial, false
 
-        @token.partial = true
+        token.partial = true
 
-        @token.instance_variable_get(:@partial).should be_false
+        token.should_not be_partial
       end
       it 'should not set partial' do
-        @token.partial = false
+        token.partial = false
 
-        @token.instance_variable_get(:@partial).should be_true
+        token.should be_partial
       end
     end
   end
@@ -395,27 +408,27 @@ describe Picky::Query::Token do
     it 'should not partialize a token if the text ends with "' do
       token = described_class.processed 'text"'
 
-      token.instance_variable_get(:@partial).should be_false
+      token.should_not be_partial
     end
     it 'should partialize a token if the text ends with *' do
       token = described_class.processed 'text*'
 
-      token.instance_variable_get(:@partial).should be_true
+      token.should be_partial
     end
     it 'should not partialize a token if the text ends with ~' do
       token = described_class.processed 'text~'
 
-      token.instance_variable_get(:@partial).should be_nil
+      token.should_not be_partial
     end
     it 'lets the last one win' do
       token = described_class.processed 'text"*'
 
-      token.partial?.should == true
+      token.should be_partial
     end
     it 'lets the last one win' do
       token = described_class.processed 'text*"'
 
-      token.partial?.should == false
+      token.should_not be_partial
     end
   end
 

data/spec/lib/query/tokens_spec.rb

@@ -106,6 +106,20 @@ describe Picky::Query::Tokens do
         @token.should be_partial
       end
     end
+    context 'special case' do
+      before(:each) do
+        @token = Picky::Query::Token.processed 'a"'
+        @tokens = described_class.new [@token]
+      end
+      it 'should not have a last partialized token' do
+        @token.should_not be_partial
+      end
+      it 'should not partialize the last token' do
+        @tokens.partialize_last
+
+        @token.should_not be_partial
+      end
+    end
     context 'one token' do
       before(:each) do
         @token = Picky::Query::Token.processed 'Token'

data/spec/lib/results_spec.rb

@@ -1,19 +1,19 @@
 require 'spec_helper'
 
 describe Picky::Results do
-  
+
   describe "from" do
     before(:each) do
       @results = stub :results
       described_class.stub! :new => @results
-      
+
       @results.stub! :prepare!
     end
     it "should generate a result" do
       described_class.from("some query", 20, 0, @allocations).should == @results
     end
   end
-  
+
   describe "ids" do
     before(:each) do
       @allocations = stub :allocations
@@ -21,14 +21,20 @@ describe Picky::Results do
     end
     it "delegates" do
       @allocations.should_receive(:ids).once.with :anything
-      
+
       @results.ids :anything
     end
   end
-  
+
+  describe 'to_s time format' do
+    it 'is in the right format' do
+      described_class.new("some_query").to_s.should match(/\d{2}\-\d{2}-\d{2} \d{2}:\d{2}:\d{2}/)
+    end
+  end
+
   describe 'to_s' do
     before(:each) do
-      time = stub :time, :to_s => '0-08-16 10:07:33'
+      time = stub :time, :strftime => '2011-08-16 10:07:33'
       Time.stub! :now => time
     end
     context 'without results' do
@@ -36,7 +42,7 @@ describe Picky::Results do
         @results = described_class.new "some_query"
       end
       it 'should output a default log' do
-        @results.to_s.should == '.|0-08-16 10:07:33|0.000000|some_query                                        |       0|   0| 0|'
+        @results.to_s.should == '.|2011-08-16 10:07:33|0.000000|some_query                                        |       0|   0| 0|'
       end
     end
     context 'with results' do
@@ -50,7 +56,7 @@ describe Picky::Results do
                        :total    => 12345678
       end
       it 'should output a specific log' do
-        @results.to_s.should == '>|0-08-16 10:07:33|0.123457|some_query                                        |12345678|1234|12|'
+        @results.to_s.should == '>|2011-08-16 10:07:33|0.123457|some_query                                        |12345678|1234|12|'
       end
     end
   end