picky 4.0.0pre6 → 4.0.0

data/spec/lib/api/category/partial_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Picky::API::Category::Partial do
+  let(:object) do
+    Class.new do
+      include Picky::API::Category::Partial
+
+      def index_name
+        :some_index
+      end
+      def name
+        :some_category
+      end
+    end.new
+  end
+  context 'extract_partial' do
+    context 'with nil' do
+      it 'returns the default' do
+        object.extract_partial(nil).should == Picky::Partial::Default
+      end
+    end
+    context 'with a partial object' do
+      let(:partializer) do
+        Class.new do
+          def each_partial text
+            'tex'
+          end
+        end.new
+      end
+      it 'yields the partial' do
+        object.extract_partial(partializer).each_partial('whatevs') do |text|
+          text.should == 'tex'
+        end
+      end
+    end
+    context 'invalid weight' do
+      it 'raises with a nice error message' do
+        expect {
+          object.extract_partial Object.new
+        }.to raise_error(<<-ERROR)
+partial options for some_index:some_category should be either
+* for example a Partial::Substring.new(from: m, to: n), Partial::Postfix.new(from: n), Partial::Infix.new(min: m, max: n) etc.
+or
+* an object that responds to #each_partial(str_or_sym) and yields each partial
+ERROR
+      end
+    end
+  end
+end

data/spec/lib/api/category/similarity_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Picky::API::Category::Similarity do
+  let(:object) do
+    Class.new do
+      include Picky::API::Category::Similarity
+
+      def index_name
+        :some_index
+      end
+      def name
+        :some_category
+      end
+    end.new
+  end
+  context 'encode' do
+    context 'with nil' do
+      it 'returns the default' do
+        object.extract_similarity(nil).should == Picky::Similarity::Default
+      end
+    end
+    context 'with a similarity object' do
+      let(:similarizer) do
+        Class.new do
+          def encode text
+            :encoded
+          end
+          def prioritize ary, encoded
+
+          end
+        end.new
+      end
+      it 'returns the encoded string' do
+        object.extract_similarity(similarizer).encode('whatevs').should == :encoded
+      end
+    end
+    context 'invalid weight' do
+      it 'raises with a nice error message' do
+        expect {
+          object.extract_similarity Object.new
+        }.to raise_error(<<-ERROR)
+similarity options for some_index:some_category should be either
+* for example a Similarity::Phonetic.new(n), Similarity::Metaphone.new(n), Similarity::DoubleMetaphone.new(n) etc.
+or
+* an object that responds to #encode(text) => encoded_text and #prioritize(array_of_encoded, encoded)
+ERROR
+      end
+    end
+  end
+end

data/spec/lib/api/category/weight_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Picky::API::Category::Weight do
+  let(:object) do
+    Class.new do
+      include Picky::API::Category::Weight
+
+      def index_name
+        :some_index
+      end
+      def name
+        :some_category
+      end
+    end.new
+  end
+  context 'extract_weight' do
+    context 'with nil' do
+      it 'returns the default' do
+        object.extract_weight(nil).should == Picky::Weights::Default
+      end
+    end
+    context 'with a weight object' do
+      let(:weighter) do
+        Class.new do
+          def weight_for amount
+            7.0
+          end
+        end.new
+      end
+      it 'creates a tokenizer' do
+        object.extract_weight(weighter).weight_for(21).should == 7.0
+      end
+    end
+    context 'invalid weight' do
+      it 'raises with a nice error message' do
+        expect {
+          object.extract_weight Object.new
+        }.to raise_error(<<-ERROR)
+weight options for some_index:some_category should be either
+* for example a Weights::Logarithmic.new, Weights::Constant.new(int = 0), Weights::Dynamic.new(&block) etc.
+or
+* an object that responds to #weight_for(amount_of_ids_for_token) => float
+ERROR
+      end
+    end
+  end
+end

data/spec/lib/api/search/boost_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Picky::API::Search::Boost do
+  let(:object) do
+    Class.new do
+      include Picky::API::Search::Boost
+    end.new
+  end
+  context 'extract_weight' do
+    context 'with a Hash' do
+      it 'returns a boosts object' do
+        combinations = [
+          stub(:combination, :category_name => :bla)
+        ]
+
+        object.extract_boosts([:bla] => +7.77).boost_for(combinations).should == 7.77
+      end
+    end
+    context 'with a boosts object' do
+      let(:booster) do
+        Class.new do
+          def boost_for whatever
+            7.0
+          end
+        end.new
+      end
+      it 'returns a boosts object' do
+        object.extract_boosts(booster).boost_for(:anything).should == 7.0
+      end
+    end
+    context 'invalid weight' do
+      it 'raises with a nice error message' do
+        expect {
+          object.extract_boosts Object.new
+        }.to raise_error(<<-ERROR)
+boost options for a Search should be either
+* for example a Hash { [:name, :surname] => +3 }
+or
+* an object that responds to #boost_for(combinations) and returns a boost float
+ERROR
+      end
+    end
+  end
+end

data/spec/lib/api/source_spec.rb

@@ -0,0 +1,68 @@
+require 'spec_helper'
+
+describe Picky::API::Source do
+  let(:object) do
+    Class.new do
+      include Picky::API::Source
+    end.new
+  end
+  context 'unblock_source' do
+    before(:each) do
+      class << object
+        def source_with source = nil, &block
+          @source = source || block
+        end
+      end
+    end
+    context 'with block' do
+      it 'unblocks' do
+        object.source_with do
+          :some_source
+        end
+
+        object.unblock_source == :some_source
+      end
+    end
+    context 'with #each' do
+      it 'takes the source directly' do
+        object.source_with :some_source
+
+        object.unblock_source == :some_source
+      end
+    end
+  end
+  context 'extract_source' do
+    context 'block with source hash' do
+      it 'extracts a source' do
+        object.extract_source(Proc.new {}).should be_kind_of(Proc)
+      end
+    end
+    context 'each source' do
+      let(:source) do
+        Class.new do
+          def each
+
+          end
+        end.new
+      end
+      it 'extracts a source' do
+        object.extract_source(source).should == source
+      end
+    end
+    context 'invalid tokenizer' do
+      it 'raises with a nice error message' do
+        expect {
+          object.extract_source Object.new
+        }.to raise_error(<<-ERROR)
+The source should respond to either the method #each or
+it can be a lambda/block, returning such a source.
+ERROR
+      end
+    end
+    context 'with nil_ok option' do
+      it 'simply returns nil back' do
+        object.extract_source(nil, nil_ok: true).should == nil
+      end
+    end
+  end
+end

data/spec/lib/api/tokenizer/character_substituter_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Picky::API::Tokenizer do
+  let(:object) do
+    Class.new do
+      include Picky::API::Tokenizer::CharacterSubstituter
+    end.new
+  end
+  context 'extract_character_substituter' do
+    context 'with a substituter' do
+      let(:substituter) do
+        Class.new do
+          def substitute text
+            text.tr('a-z', '1-9')
+          end
+        end.new
+      end
+      it 'creates a tokenizer' do
+        object.extract_character_substituter(substituter).
+          substitute("picky").should == '99399'
+      end
+    end
+    context 'invalid tokenizer' do
+      it 'raises with a nice error message' do
+        expect {
+          object.extract_character_substituter Object.new
+        }.to raise_error(<<-ERROR)
+The substitutes_characters_with option needs a character substituter,
+which responds to #substitute(text) and returns substituted_text."
+ERROR
+      end
+    end
+  end
+end

data/spec/lib/api/tokenizer_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe Picky::API::Tokenizer do
+  let(:object) do
+    Class.new do
+      include Picky::API::Tokenizer
+    end.new
+  end
+  context 'extract_tokenizer' do
+    context 'options hash' do
+      it 'creates a tokenizer' do
+        object.extract_tokenizer(indexing: { splits_text_on: /\t/ }).
+          tokenize("hello\tworld").should == [['hello', 'world'], ['hello', 'world']]
+      end
+    end
+    context 'tokenizer' do
+      let(:tokenizer) do
+        Class.new do
+          def tokenize text
+            ['unmoved', 'by', 'your', 'texts']
+          end
+        end.new
+      end
+      it 'creates a tokenizer' do
+        object.extract_tokenizer(tokenizer).
+          tokenize("hello\tworld").should == ['unmoved', 'by', 'your', 'texts']
+      end
+    end
+    context 'invalid tokenizer' do
+      it 'raises with a nice error message' do
+        expect {
+          object.extract_tokenizer Object.new
+        }.to raise_error(<<-ERROR)
+indexing options should be either
+* a Hash
+or
+* an object that responds to #tokenize(text) => [[token1, ...], [original1, ...]]
+ERROR
+      end
+    end
+  end
+end

data/spec/lib/category_indexed_spec.rb

@@ -6,9 +6,9 @@ describe Picky::Category do
     @index = Picky::Index.new :some_index do
       source []
     end
-    @partial_strategy    = stub :partial, :use_exact_for_partial? => false
+    @partial_strategy    = stub :partial, :each_partial => nil, :use_exact_for_partial? => false
     @weight_strategy    = stub :weights, :saved? => true
-    @similarity_strategy = stub :similarity
+    @similarity_strategy = stub :similarity, :encode => nil, :prioritize => nil
 
     @exact   = stub :exact, :dump => nil
     @partial = stub :partial, :dump => nil

data/spec/lib/category_indexing_spec.rb

@@ -4,7 +4,7 @@ describe Picky::Category do
 
   before(:each) do
     @index  = Picky::Index.new :some_index
-    @source = stub :some_given_source, :key_format => nil
+    @source = stub :some_given_source, :each => nil
   end
   let(:category) { described_class.new(:some_category, @index, :source => @source).tap { |c| c.stub! :timed_exclaim } }
 
@@ -70,37 +70,24 @@ describe Picky::Category do
     end
 
     describe 'key_format' do
-      context 'source has key_format' do
+      context 'category has its own key_format' do
         before(:each) do
-          category.stub! :source => stub(:source, :key_format => :some_key_format)
+          category.instance_variable_set :@key_format, :other_key_format
         end
         it 'returns that key_format' do
-          category.key_format.should == :some_key_format
+          category.key_format.should == :other_key_format
         end
       end
-      context 'source does not have key_format' do
+      context 'category does not have its own key format' do
         before(:each) do
-          category.stub! :source => stub(:source)
+          category.instance_variable_set :@key_format, nil
         end
-        context 'category has its own key_format' do
+        context 'it has an index' do
           before(:each) do
-            category.instance_variable_set :@key_format, :other_key_format
+            category.instance_variable_set :@index, stub(:index, :key_format => :yet_another_key_format)
           end
           it 'returns that key_format' do
-            category.key_format.should == :other_key_format
-          end
-        end
-        context 'category does not have its own key format' do
-          before(:each) do
-            category.instance_variable_set :@key_format, nil
-          end
-          context 'it has an index' do
-            before(:each) do
-              category.instance_variable_set :@index, stub(:index, :key_format => :yet_another_key_format)
-            end
-            it 'returns that key_format' do
-              category.key_format.should == :yet_another_key_format
-            end
+            category.key_format.should == :yet_another_key_format
           end
         end
       end
@@ -108,9 +95,9 @@ describe Picky::Category do
 
     describe 'source' do
       context 'with explicit source' do
-        let(:category) { described_class.new(:some_category, @index, :source => :category_source) }
+        let(:category) { described_class.new(:some_category, @index, :source => [1]) }
         it 'returns the right source' do
-          category.source.should == :category_source
+          category.source.should == [1]
         end
       end
       context 'without explicit source' do

data/spec/lib/category_spec.rb

@@ -3,22 +3,59 @@ require 'spec_helper'
 describe Picky::Category do
 
   let(:index) { Picky::Index.new :some_index }
-  let(:category) { described_class.new :some_category, index }
 
-  it 'should set defaults correctly' do
-    category.exact.weight_strategy.should == Picky::Generators::Weights::Default
-    category.exact.partial_strategy.should be_kind_of(Picky::Generators::Partial::None)
-    category.exact.similarity_strategy.should == Picky::Generators::Similarity::Default
+  context 'default parameters' do
+    let(:category) { described_class.new :some_category, index }
 
-    category.partial.weight_strategy.should be_kind_of(Picky::Generators::Weights::Logarithmic)
-    category.partial.partial_strategy.should == Picky::Generators::Partial::Default
-    category.partial.similarity_strategy.should be_kind_of(Picky::Generators::Similarity::None)
+    it 'should set defaults correctly' do
+      category.exact.weight_strategy.should == Picky::Generators::Weights::Default
+      category.exact.partial_strategy.should be_kind_of(Picky::Generators::Partial::None)
+      category.exact.similarity_strategy.should == Picky::Generators::Similarity::Default
 
-    category.exact.similarity_strategy.should == Picky::Generators::Similarity::Default
+      category.partial.weight_strategy.should be_kind_of(Picky::Generators::Weights::Logarithmic)
+      category.partial.partial_strategy.should == Picky::Generators::Partial::Default
+      category.partial.similarity_strategy.should be_kind_of(Picky::Generators::Similarity::None)
 
-    category.partial.similarity_strategy.should be_kind_of(Picky::Generators::Similarity::None)
+      category.exact.similarity_strategy.should == Picky::Generators::Similarity::Default
 
-    category.instance_variable_get(:@symbols).should == nil
+      category.partial.similarity_strategy.should be_kind_of(Picky::Generators::Similarity::None)
+
+      category.instance_variable_get(:@symbols).should == nil
+    end
+  end
+
+  context 'tokenizer' do
+    context 'options hash' do
+      let(:category) { described_class.new :some_category, index, indexing: { splits_text_on: /\t/ } }
+      it 'creates a tokenizer' do
+        category.tokenizer.tokenize("hello\tworld").should == [['hello', 'world'], ['hello', 'world']]
+      end
+    end
+    context 'tokenizer' do
+      let(:tokenizer) do
+        Class.new do
+          def tokenize text
+            ['unmoved', 'by', 'your', 'texts']
+          end
+        end.new
+      end
+      let(:category) { described_class.new :some_category, index, indexing: tokenizer }
+      it 'creates a tokenizer' do
+        category.tokenizer.tokenize("hello\tworld").should == ['unmoved', 'by', 'your', 'texts']
+      end
+    end
+    context 'invalid tokenizer' do
+      it 'raises with a nice error message' do
+        expect {
+          described_class.new :some_category, index, indexing: Object.new
+        }.to raise_error(<<-ERROR)
+indexing options for some_index:some_category should be either
+* a Hash
+or
+* an object that responds to #tokenize(text) => [[token1, ...], [original1, ...]]
+ERROR
+      end
+    end
   end
 
 end

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

@@ -10,7 +10,7 @@ describe Picky::Generators::Similarity::DoubleMetaphone do
 
   def self.it_should_encode text, expected
     it "should encode #{text.inspect} correctly" do
-      @similarity.encoded(text).should == expected
+      @similarity.encode(text).should == expected
     end
   end
   # def self.it_should_generate_from index, expected

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

@@ -10,7 +10,7 @@ describe Picky::Generators::Similarity::Metaphone do
 
   def self.it_should_encode text, expected
     it "should encode #{text.inspect} correctly" do
-      @similarity.encoded(text).should == expected
+      @similarity.encode(text).should == expected
     end
   end
   # def self.it_should_generate_from index, expected

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

@@ -16,7 +16,7 @@ describe Picky::Generators::Similarity::None do
 
   describe 'encode' do
     it 'should always return nil' do
-      @similarity.encoded(:whatever).should == nil
+      @similarity.encode(:whatever).should == nil
     end
   end
 

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

@@ -10,7 +10,7 @@ describe Picky::Generators::Similarity::Soundex do
 
   def self.it_should_encode text, expected
     it "should encode #{text.inspect} correctly" do
-      @similarity.encoded(text).should == expected
+      @similarity.encode(text).should == expected
     end
   end
   # def self.it_should_generate_from index, expected

data/spec/lib/index_indexing_spec.rb

@@ -69,21 +69,17 @@ describe Picky::Index do
     end
     context 'with non#each source' do
       let(:source) { stub :source, :harvest => nil }
-      let(:index) do
-        the_source = source
-        described_class.new :some_name do
-          source the_source
-        end
-      end
 
-      it 'does things in order' do
-        categories = stub :categories
-        index.stub! :categories => categories
-
-        categories.should_receive(:prepare).once
-        categories.should_receive(:cache).once
-
-        index.index
+      it 'raises' do
+        the_source = source
+        expect {
+          described_class.new :some_name do
+            source the_source
+          end
+        }.to raise_error(<<-ERROR)
+The some_name source should respond to either the method #each or
+it can be a lambda/block, returning such a source.
+ERROR
       end
     end
   end

data/spec/lib/index_spec.rb

@@ -4,7 +4,7 @@ require 'spec_helper'
 
 describe Picky::Index do
 
-  let(:some_source) { stub :source, :harvest => nil, :inspect => 'some_source' }
+  let(:some_source) { stub :source, :each => nil, :inspect => 'some_source' }
 
   context 'initializer' do
     it 'works' do

data/spec/lib/query/allocation_spec.rb

@@ -180,9 +180,9 @@ describe Picky::Query::Allocation do
     context 'non-empty combinations' do
       it 'should delegate to backend and combinations' do
         @backend.should_receive(:weight).once.with(@combinations).and_return 1
-        @combinations.should_receive(:weighted_score).once.with(:some_weights).and_return 2
+        @combinations.should_receive(:boost_for).once.with(:some_boosts).and_return 2
 
-        @allocation.calculate_score(:some_weights).should == 3
+        @allocation.calculate_score(:some_boosts).should == 3
       end
     end
     context 'empty combinations' do

data/spec/lib/query/boosts_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+
+describe Picky::Query::Boosts do
+
+  context 'with boosts' do
+    let(:boosts) do
+      described_class.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 'boost_for' do
+      it 'gets the category names from the combinations' do
+        combinations = [
+          stub(:combination1, :category_name => :test1),
+          stub(:combination1, :category_name => :test2)
+        ]
+
+        boosts.boost_for(combinations).should == +6
+      end
+    end
+
+    describe "weight_for" do
+      it "should return zero if there is no specific weight" do
+        boosts.boost_for_categories([:not_a_specific_allocation]).should be_zero
+      end
+    end
+
+    def self.it_should_return_a_specific_boost_for(allocation, boost)
+      it "should return boost #{boost} for #{allocation.inspect}" do
+        boosts.boost_for_categories(allocation).should == boost
+      end
+    end
+
+    it_should_return_a_specific_boost_for [:test1, :test2],         6
+    it_should_return_a_specific_boost_for [:test1],                 5
+    it_should_return_a_specific_boost_for [:test1, :test3],         2
+    it_should_return_a_specific_boost_for [:test3],                 3
+    it_should_return_a_specific_boost_for [:test3, :test2],         4
+    it_should_return_a_specific_boost_for [:test1, :test4],         5
+    it_should_return_a_specific_boost_for [:test4, :test1],         5
+    it_should_return_a_specific_boost_for [:test4, :test1, :test2], 4
+    it_should_return_a_specific_boost_for [:test1, :test4, :test2], 4
+    it_should_return_a_specific_boost_for [:test4, :test5],         3
+    it_should_return_a_specific_boost_for [:test5, :test1],         2
+    it_should_return_a_specific_boost_for [:test1, :test5],         2
+    it_should_return_a_specific_boost_for [:test3, :test1],         2
+
+    describe 'to_s' do
+      it 'is correct' do
+        boosts.to_s.should == "Picky::Query::Boosts({[: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
+    end
+    describe 'empty?' do
+      it 'is correct' do
+        boosts.empty?.should == false
+      end
+    end
+  end
+  context 'without boosts' do
+    let(:boosts) { described_class.new }
+    describe 'empty?' do
+      it 'is correct' do
+        boosts.empty?.should == true
+      end
+    end
+  end
+
+end