picky 0.0.0 → 0.0.2

data/spec/lib/query/token_spec.rb

@@ -0,0 +1,297 @@
+# coding: utf-8
+require 'spec_helper'
+
+describe Query::Token do
+  
+  before(:all) do
+    Query::Qualifiers.instance << Query::Qualifier.new(:specific, [:sp, :spec])
+    Query::Qualifiers.instance.prepare
+  end
+  
+  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
+      end
+    end
+    it_should_solr 's',            's'
+    it_should_solr 'se',           'se'
+    it_should_solr 'sea',          'sea'
+    it_should_solr 'sear',         'sear~0.74'
+    it_should_solr 'searc',        'searc~0.78'
+    it_should_solr 'search',       'search~0.81'
+    it_should_solr 'searche',      'searche~0.83'
+    it_should_solr 'searchen',     'searchen~0.85'
+    it_should_solr 'searcheng',    'searcheng~0.87'
+    it_should_solr 'searchengi',   'searchengi~0.89'
+    it_should_solr 'searchengin',  'searchengin~0.9'
+    it_should_solr 'searchengine', 'searchengine~0.9'
+
+    it_should_solr 'spec:tex',     'specific:tex'
+    it_should_solr 'with:text',    'text~0.74'
+    it_should_solr 'name:',        'name~0.74'
+    it_should_solr '',             ''
+    it_should_solr 'sp:tex',       'specific:tex'
+    it_should_solr 'sp:tex~',      'specific:tex'
+    it_should_solr 'sp:tex"',      'specific:tex'
+  end
+
+  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
+      end
+    end
+    it_should_qualify 'spec:qualifier',    :specific
+    it_should_qualify 'with:qualifier',    nil
+    it_should_qualify 'without qualifier', nil
+    it_should_qualify 'name:',             nil
+    it_should_qualify ':broken qualifier', nil
+    it_should_qualify '',                  nil
+    it_should_qualify 'sp:text',           :specific
+  end
+
+  describe 'processed' do
+    it 'should have an order' do
+      token = stub :token
+      Query::Token.should_receive(:new).once.and_return token
+
+      token.should_receive(:qualify).once.ordered
+      token.should_receive(:extract_original).once.ordered
+      token.should_receive(:partialize).once.ordered
+      token.should_receive(:similarize).once.ordered
+      token.should_receive(:remove_illegals).once.ordered
+
+      Query::Token.processed :any_text
+    end
+    it 'should return a new token' do
+      Query::Token.processed('some text').should be_kind_of(Query::Token)
+    end
+  end
+
+  describe 'partial?' do
+    context 'similar, partial' do
+      before(:each) do
+        @token = Query::Token.processed 'similar~'
+        @token.partial = true
+      end
+      it 'should be false' do
+        @token.partial?.should == false
+      end
+    end
+    context 'similar, not partial' do
+      before(:each) do
+        @token = Query::Token.processed 'similar~'
+      end
+      it 'should be false' do
+        @token.partial?.should == false
+      end
+    end
+    context 'not similar, partial' do
+      before(:each) do
+        @token = Query::Token.processed 'not similar'
+        @token.partial = true
+      end
+      it 'should be true' do
+        @token.partial?.should == true
+      end
+    end
+    context 'not similar, not partial' do
+      before(:each) do
+        @token = Query::Token.processed 'not similar'
+      end
+      it 'should be nil' do
+        @token.partial?.should == nil
+      end
+    end
+  end
+
+  describe 'similar' do
+    it 'should not change the original with the text' do
+      token = Query::Token.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
+      end
+    end
+    it_should_have_similarity 'name:',      nil
+    it_should_have_similarity 'name:hanke', nil
+    it_should_have_similarity 'g:gaga',     nil
+    it_should_have_similarity ':nothing',   nil
+    it_should_have_similarity 'hello',      nil
+    it_should_have_similarity 'a:b:c',      nil
+
+    it_should_have_similarity '""',         false
+    it_should_have_similarity '"exact~"',   false # The tilde will just be removed
+
+    it_should_have_similarity '~',          true
+    it_should_have_similarity '"hello"~',   true # overrides the ""
+    it_should_have_similarity 'philippe~',  true
+  end
+
+  describe 'special cases' do
+    it 'should be blank on ""' do
+      token = Query::Token.processed '""'
+
+      token.should be_blank
+    end
+  end
+
+  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
+      end
+    end
+    it_should_split '""',         [nil, '""']
+    it_should_split 'name:',      [nil, 'name']
+    it_should_split 'name:hanke', ['name', 'hanke']
+    it_should_split 'g:gaga',     ['g', 'gaga']
+    it_should_split ':nothing',   ['', 'nothing']
+    it_should_split 'hello',      [nil, 'hello']
+    it_should_split 'a:b:c',      ['a', 'b:c']
+  end
+
+  describe "original" do
+    it "should keep the original text even when processed" do
+      token = Query::Token.processed "I'm the original token text."
+
+      token.original.should == "I'm the original token text."
+    end
+  end
+
+  describe "blank?" do
+    it "should be blank if the token text itself is blank" do
+      token = Query::Token.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.blank?.should be_false
+    end
+  end
+
+  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.to_s.should == 'specific:qualifier'
+      end
+    end
+    describe "without qualifier" do
+      it "should display just the text" do
+        token = Query::Token.processed('text')
+
+        token.to_s.should == 'text'
+      end
+    end
+  end
+
+  describe 'user_defined_category_name' do
+    context 'with qualifier' do
+      before(:each) do
+        @token = Query::Token.processed('sp:qualifier')
+      end
+      it 'should return the qualifier' do
+        @token.user_defined_category_name.should == :specific
+      end
+    end
+    context 'without qualifier' do
+      before(:each) do
+        @token = Query::Token.processed('noqualifier')
+      end
+      it 'should return nil' do
+        @token.user_defined_category_name.should == nil
+      end
+    end
+  end
+
+  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
+      end
+    end
+    it_should_split ':',                 [nil,        '']
+    it_should_split 'vorname:qualifier', ['vorname', 'qualifier']
+    it_should_split 'with:qualifier',    ['with',    'qualifier']
+    it_should_split 'without qualifier', [nil,       'without qualifier']
+    it_should_split 'name:',             [nil,       'name']
+    it_should_split ':broken qualifier', ['',        'broken qualifier']
+    it_should_split '',                  [nil,       '']
+    it_should_split 'fn:text',           ['fn',      'text']
+  end
+
+  describe 'partial=' do
+    context 'partial nil' do
+      before(:each) do
+        @token = Query::Token.new 'text'
+      end
+      it 'should set partial' do
+        @token.partial = true
+
+        @token.instance_variable_get(:@partial).should be_true
+      end
+      it 'should set partial' do
+        @token.partial = false
+
+        @token.instance_variable_get(:@partial).should be_false
+      end
+    end
+    context 'partial not nil' do
+      before(:each) do
+        @token = Query::Token.processed 'text*'
+      end
+      it 'should not set partial' do
+        @token.partial = false
+
+        @token.instance_variable_get(:@partial).should be_true
+      end
+    end
+  end
+
+  describe 'partialize!' do
+    it 'should not partialize a token if the text ends with "' do
+      token = Query::Token.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.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.instance_variable_get(:@partial).should be_nil
+    end
+  end
+
+  describe "processed" do
+    it 'should remove *' do
+      token = Query::Token.processed 'text*'
+
+      token.text.should == 'text'
+    end
+    it 'should remove ~' do
+      token = Query::Token.processed 'text~'
+
+      token.text.should == 'text'
+    end
+    it 'should remove "' do
+      token = Query::Token.processed 'text"'
+
+      token.text.should == 'text'
+    end
+    it "should pass on a processed text" do
+      Query::Token.processed('text').text.should == 'text'
+    end
+  end
+
+end

data/spec/lib/query/tokens_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+
+describe Query::Tokens do
+  
+  before(:all) do
+    Query::Qualifiers.instance << Query::Qualifier.new(:specific, [:sp, :spec])
+    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"')
+        ]
+      end
+      it 'should output a correct solr query' do
+        @tokens.to_solr_query.should == 'this~0.74 is a specific:solr~0.74 query~0.78'
+      end
+    end
+  end
+
+  describe 'reject' do
+    before(:each) do
+      @blank    = stub :blank, :blank? => true
+      @nonblank = stub :nonblank, :blank? => false
+      @tokens = Query::Tokens.new [@blank, @nonblank, @blank, @blank, @nonblank]
+    end
+    it 'should not cut it down' do
+      @tokens.reject
+
+      @tokens.instance_variable_get(:@tokens).should == [@nonblank, @nonblank]
+    end
+  end
+
+  describe "class variables" do
+    describe "maximal query words" do
+      it "should answer" do
+        lambda { Query::Tokens.maximum }.should_not raise_error
+      end
+    end
+  end
+
+  describe 'cap' do
+    context 'one token' do
+      before(:each) do
+        @token = Query::Token.processed 'Token'
+        @tokens = Query::Tokens.new [@token]
+      end
+      it 'should not cut it down' do
+        @tokens.cap
+
+        @tokens.instance_variable_get(:@tokens).should == [@token]
+      end
+    end
+    context 'many tokens' do
+      before(:each) do
+        @old_maximum = Query::Tokens.maximum
+        Query::Tokens.maximum = 3
+        @first = Query::Token.processed 'Hello'
+        @second = Query::Token.processed 'I'
+        @third = Query::Token.processed 'Am'
+        @tokens = Query::Tokens.new [
+          @first,
+          @second,
+          @third,
+          Query::Token.processed('A'),
+          Query::Token.processed('Token')
+        ]
+      end
+      after(:each) do
+        Query::Tokens.maximum = @old_maximum
+      end
+      it 'should cap the number of tokens' do
+        @tokens.cap
+
+        @tokens.instance_variable_get(:@tokens).should == [@first, @second, @third]
+      end
+    end
+  end
+
+  describe 'partialize_last' do
+    context 'special case' do
+      before(:each) do
+        @token = Query::Token.processed 'a*'
+        @tokens = Query::Tokens.new [@token]
+      end
+      it 'should have a last partialized token' do
+        @token.should be_partial
+      end
+      it 'should still partialize the last token' do
+        @tokens.partialize_last
+
+        @token.should be_partial
+      end
+    end
+    context 'one token' do
+      before(:each) do
+        @token = Query::Token.processed 'Token'
+        @tokens = Query::Tokens.new [@token]
+      end
+      it 'should not have a last partialized token' do
+        @token.should_not be_partial
+      end
+      it 'should partialize the last token' do
+        @tokens.partialize_last
+
+        @token.should be_partial
+      end
+    end
+    context 'many tokens' do
+      before(:each) do
+        @first = Query::Token.processed 'Hello'
+        @last = Query::Token.processed 'Token'
+        @tokens = Query::Tokens.new [
+          @first,
+          Query::Token.processed('I'),
+          Query::Token.processed('Am'),
+          Query::Token.processed('A'),
+          @last
+        ]
+      end
+      it 'should not have a last partialized token' do
+        @last.should_not be_partial
+      end
+      it 'should partialize the last token' do
+        @tokens.partialize_last
+
+        @last.should be_partial
+      end
+      it 'should not partialize any other token' do
+        @tokens.partialize_last
+
+        @first.should_not be_partial
+      end
+    end
+  end
+
+  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~')
+      ]
+    end
+    it 'should work correctly' do
+      @tokens.to_s.should == 'Hello~ I~ Am A* Token~'
+    end
+  end
+
+  def self.it_should_delegate name
+    describe name do
+      before(:each) do
+        @internal_tokens = mock :internal_tokens
+        @tokens = Query::Tokens.new @internal_tokens
+      end
+      it "should delegate #{name} to the internal tokens" do
+        proc_stub = lambda {}
+
+        @internal_tokens.should_receive(name).once.with &proc_stub
+
+        @tokens.send name, &proc_stub
+      end
+    end
+  end
+  # Reject is tested separately.
+  #
+  (Enumerable.instance_methods - [:reject]).each do |name|
+    it_should_delegate name
+  end
+  it_should_delegate :slice!
+  it_should_delegate :[]
+  it_should_delegate :uniq!
+  it_should_delegate :last
+  it_should_delegate :length
+  it_should_delegate :reject!
+  it_should_delegate :size
+  it_should_delegate :empty?
+  it_should_delegate :each
+  it_should_delegate :exit
+
+end

data/spec/lib/query/weights_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Query::Weights do
+
+  before(:each) do
+    @weights = Query::Weights.new [:test1, :test2]         => 6,
+                                     [:test1]                 => 5,
+                                     [:test3]                 => 3,
+                                     [:test3, :test2]         => 4,
+                                     [:test1, :test4]         => 5,
+                                     [:test4, :test1]         => 5,
+                                     [:test4, :test1, :test2] => 4,
+                                     [:test1, :test4, :test2] => 4,
+                                     [:test4, :test5]         => 3,
+                                     [:test5, :test1]         => 2,
+                                     [:test1, :test5]         => 2,
+                                     [:test3, :test1]         => 2,
+                                     [:test1, :test3]         => 2
+  end
+
+  describe "weight_for" do
+    it "should return zero if there is no specific weight" do
+      @weights.weight_for([:not_a_specific_allocation]).should be_zero
+    end
+  end
+  
+  def self.it_should_return_a_specific_weight_for(allocation, weight)
+    it "should return weight #{weight} for #{allocation.inspect}" do
+      @weights.weight_for(allocation).should == weight
+    end
+  end
+  
+  it_should_return_a_specific_weight_for [:test1, :test2],         6
+  it_should_return_a_specific_weight_for [:test1],                 5
+  it_should_return_a_specific_weight_for [:test1, :test3],         2
+  it_should_return_a_specific_weight_for [:test3],                 3
+  it_should_return_a_specific_weight_for [:test3, :test2],         4
+  it_should_return_a_specific_weight_for [:test1, :test4],         5
+  it_should_return_a_specific_weight_for [:test4, :test1],         5
+  it_should_return_a_specific_weight_for [:test4, :test1, :test2], 4
+  it_should_return_a_specific_weight_for [:test1, :test4, :test2], 4
+  it_should_return_a_specific_weight_for [:test4, :test5],         3
+  it_should_return_a_specific_weight_for [:test5, :test1],         2
+  it_should_return_a_specific_weight_for [:test1, :test5],         2
+  it_should_return_a_specific_weight_for [:test3, :test1],         2
+  
+end