picky 3.5.0 → 3.5.1

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

@@ -13,48 +13,48 @@ describe Picky::Generators::Similarity::DoubleMetaphone do
       @similarity.encoded(text).should == expected
     end
   end
-  def self.it_should_generate_from index, expected
-    it "should generate #{expected.inspect} correctly from #{index.inspect}" do
-      @similarity.generate_from(index).should == expected
-    end
-  end
+  # def self.it_should_generate_from index, expected
+  #   it "should generate #{expected.inspect} correctly from #{index.inspect}" do
+  #     @similarity.generate_from(index).should == expected
+  #   end
+  # end
 
   it_should_encode :meier,       :MR
   it_should_encode :grossberger, :KRSP
   it_should_encode :hadelbla,    :HTLP
 
-  it_should_generate_from({}, {})
-  it_should_generate_from({ :maier => nil, :meier => nil }, :MR => [:maier, :meier]) # should be correctly ordered
-  it_should_generate_from({ :maier => nil, :meier => nil, :hallaballa => nil }, :MR => [:maier, :meier], :HLPL => [:hallaballa])
-  it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :SSN => [:susan, :susanne], :PRTR => [:bruderer])
-
-  describe 'with reduced amount' do
-    before(:each) do
-      @similarity = described_class.new(1)
-    end
-    it_should_generate_from({ :maier => nil, :meier => nil }, :MR => [:maier])
-    it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :SSN => [:susan], :PRTR => [:bruderer])
-  end
-
-  describe 'hashify' do
-    it 'should turn an empty list into an empty hash' do
-      @similarity.send(:hashify, []).should == {}
-    end
-    it 'should turn the list into an unordered similarity' do
-      @similarity.send(:hashify, [:meier, :maier]).should == { :MR => [:meier, :maier] }
-    end
-    it 'should turn the list into a encoded hash' do
-      @similarity.send(:hashify, [:meier, :maier, :peter]).should == { :MR => [:meier, :maier], :PTR => [:peter] }
-    end
-  end
-
-  context 'integration' do
-    it 'should return the right ordered array' do
-      index = @similarity.generate_from :meier => nil, :maier => nil, :mairai => nil, :mair => nil, :meira => nil
-      code  = @similarity.encoded :maier
-
-      index[code].should == [:mair, :maier, :meier, :meira, :mairai]
-    end
-  end
+  # it_should_generate_from({}, {})
+  # it_should_generate_from({ :maier => nil, :meier => nil }, :MR => [:maier, :meier]) # should be correctly ordered
+  # it_should_generate_from({ :maier => nil, :meier => nil, :hallaballa => nil }, :MR => [:maier, :meier], :HLPL => [:hallaballa])
+  # it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :SSN => [:susan, :susanne], :PRTR => [:bruderer])
+
+  # describe 'with reduced amount' do
+  #   before(:each) do
+  #     @similarity = described_class.new(1)
+  #   end
+  #   it_should_generate_from({ :maier => nil, :meier => nil }, :MR => [:maier])
+  #   it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :SSN => [:susan], :PRTR => [:bruderer])
+  # end
+
+  # describe 'hashify' do
+  #   it 'should turn an empty list into an empty hash' do
+  #     @similarity.send(:hashify, []).should == {}
+  #   end
+  #   it 'should turn the list into an unordered similarity' do
+  #     @similarity.send(:hashify, [:meier, :maier]).should == { :MR => [:meier, :maier] }
+  #   end
+  #   it 'should turn the list into a encoded hash' do
+  #     @similarity.send(:hashify, [:meier, :maier, :peter]).should == { :MR => [:meier, :maier], :PTR => [:peter] }
+  #   end
+  # end
+  #
+  # context 'integration' do
+  #   it 'should return the right ordered array' do
+  #     index = @similarity.generate_from :meier => nil, :maier => nil, :mairai => nil, :mair => nil, :meira => nil
+  #     code  = @similarity.encoded :maier
+  #
+  #     index[code].should == [:mair, :maier, :meier, :meira, :mairai]
+  #   end
+  # end
 
 end

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

@@ -13,48 +13,48 @@ describe Picky::Generators::Similarity::Metaphone do
       @similarity.encoded(text).should == expected
     end
   end
-  def self.it_should_generate_from index, expected
-    it "should generate #{expected.inspect} correctly from #{index.inspect}" do
-      @similarity.generate_from(index).should == expected
-    end
-  end
+  # def self.it_should_generate_from index, expected
+  #   it "should generate #{expected.inspect} correctly from #{index.inspect}" do
+  #     @similarity.generate_from(index).should == expected
+  #   end
+  # end
 
   it_should_encode :meier,       :MR
   it_should_encode :grossberger, :KRSBRJR
   it_should_encode :hadelbla,    :HTLBL
 
-  it_should_generate_from({}, {})
-  it_should_generate_from({ :maier => nil, :meier => nil }, :MR => [:maier, :meier]) # should be correctly ordered
-  it_should_generate_from({ :maier => nil, :meier => nil, :hallaballa => nil }, :MR => [:maier, :meier], :HLBL => [:hallaballa])
-  it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :SSN => [:susan, :susanne], :BRTRR => [:bruderer])
-
-  describe 'with reduced amount' do
-    before(:each) do
-      @similarity = described_class.new(1)
-    end
-    it_should_generate_from({ :maier => nil, :meier => nil }, :MR => [:maier])
-    it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :SSN => [:susan], :BRTRR => [:bruderer])
-  end
-
-  describe 'hashify' do
-    it 'should turn an empty list into an empty hash' do
-      @similarity.send(:hashify, []).should == {}
-    end
-    it 'should turn the list into an unordered similarity' do
-      @similarity.send(:hashify, [:meier, :maier]).should == { :MR => [:meier, :maier] }
-    end
-    it 'should turn the list into a encoded hash' do
-      @similarity.send(:hashify, [:meier, :maier, :peter]).should == { :MR => [:meier, :maier], :PTR => [:peter] }
-    end
-  end
-
-  context 'integration' do
-    it 'should return the right ordered array' do
-      index = @similarity.generate_from :meier => nil, :maier => nil, :mairai => nil, :mair => nil, :meira => nil
-      code  = @similarity.encoded :maier
-
-      index[code].should == [:mair, :maier, :meier, :meira, :mairai]
-    end
-  end
+  # it_should_generate_from({}, {})
+  # it_should_generate_from({ :maier => nil, :meier => nil }, :MR => [:maier, :meier]) # should be correctly ordered
+  # it_should_generate_from({ :maier => nil, :meier => nil, :hallaballa => nil }, :MR => [:maier, :meier], :HLBL => [:hallaballa])
+  # it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :SSN => [:susan, :susanne], :BRTRR => [:bruderer])
+
+  # describe 'with reduced amount' do
+  #   before(:each) do
+  #     @similarity = described_class.new(1)
+  #   end
+  #   it_should_generate_from({ :maier => nil, :meier => nil }, :MR => [:maier])
+  #   it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :SSN => [:susan], :BRTRR => [:bruderer])
+  # end
+  #
+  # describe 'hashify' do
+  #   it 'should turn an empty list into an empty hash' do
+  #     @similarity.send(:hashify, []).should == {}
+  #   end
+  #   it 'should turn the list into an unordered similarity' do
+  #     @similarity.send(:hashify, [:meier, :maier]).should == { :MR => [:meier, :maier] }
+  #   end
+  #   it 'should turn the list into a encoded hash' do
+  #     @similarity.send(:hashify, [:meier, :maier, :peter]).should == { :MR => [:meier, :maier], :PTR => [:peter] }
+  #   end
+  # end
+  #
+  # context 'integration' do
+  #   it 'should return the right ordered array' do
+  #     index = @similarity.generate_from :meier => nil, :maier => nil, :mairai => nil, :mair => nil, :meira => nil
+  #     code  = @similarity.encoded :maier
+  #
+  #     index[code].should == [:mair, :maier, :meier, :meira, :mairai]
+  #   end
+  # end
 
 end

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

@@ -13,48 +13,48 @@ describe Picky::Generators::Similarity::Soundex do
       @similarity.encoded(text).should == expected
     end
   end
-  def self.it_should_generate_from index, expected
-    it "should generate #{expected.inspect} correctly from #{index.inspect}" do
-      @similarity.generate_from(index).should == expected
-    end
-  end
+  # def self.it_should_generate_from index, expected
+  #   it "should generate #{expected.inspect} correctly from #{index.inspect}" do
+  #     @similarity.generate_from(index).should == expected
+  #   end
+  # end
 
   it_should_encode :meier,       :M600
   it_should_encode :grossberger, :G621
   it_should_encode :hadelbla,    :H341
 
-  it_should_generate_from({}, {})
-  it_should_generate_from({ :maier => nil, :meier => nil }, :M600 => [:maier, :meier]) # should be correctly ordered
-  it_should_generate_from({ :maier => nil, :meier => nil, :hallaballa => nil }, :M600 => [:maier, :meier], :H414 => [:hallaballa])
-  it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :S250 => [:susan, :susanne], :B636 => [:bruderer])
-
-  describe 'with reduced amount' do
-    before(:each) do
-      @similarity = described_class.new(1)
-    end
-    it_should_generate_from({ :maier => nil, :meier => nil }, :M600 => [:maier])
-    it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :S250 => [:susan], :B636 => [:bruderer])
-  end
-
-  describe 'hashify' do
-    it 'should turn an empty list into an empty hash' do
-      @similarity.send(:hashify, []).should == {}
-    end
-    it 'should turn the list into an unordered similarity' do
-      @similarity.send(:hashify, [:meier, :maier]).should == { :M600 => [:meier, :maier] }
-    end
-    it 'should turn the list into a encoded hash' do
-      @similarity.send(:hashify, [:meier, :maier, :peter]).should == { :M600 => [:meier, :maier], :P360 => [:peter] }
-    end
-  end
-
-  context 'integration' do
-    it 'should return the right ordered array' do
-      index = @similarity.generate_from :meier => nil, :maier => nil, :mairai => nil, :mair => nil, :meira => nil
-      code  = @similarity.encoded :maier
-
-      index[code].should == [:mair, :maier, :meier, :meira, :mairai]
-    end
-  end
+  # it_should_generate_from({}, {})
+  # it_should_generate_from({ :maier => nil, :meier => nil }, :M600 => [:maier, :meier]) # should be correctly ordered
+  # it_should_generate_from({ :maier => nil, :meier => nil, :hallaballa => nil }, :M600 => [:maier, :meier], :H414 => [:hallaballa])
+  # it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :S250 => [:susan, :susanne], :B636 => [:bruderer])
+
+  # describe 'with reduced amount' do
+  #   before(:each) do
+  #     @similarity = described_class.new(1)
+  #   end
+  #   it_should_generate_from({ :maier => nil, :meier => nil }, :M600 => [:maier])
+  #   it_should_generate_from({ :susan => nil, :susanne => nil, :bruderer => nil }, :S250 => [:susan], :B636 => [:bruderer])
+  # end
+
+  # describe 'hashify' do
+  #   it 'should turn an empty list into an empty hash' do
+  #     @similarity.send(:hashify, []).should == {}
+  #   end
+  #   it 'should turn the list into an unordered similarity' do
+  #     @similarity.send(:hashify, [:meier, :maier]).should == { :M600 => [:meier, :maier] }
+  #   end
+  #   it 'should turn the list into a encoded hash' do
+  #     @similarity.send(:hashify, [:meier, :maier, :peter]).should == { :M600 => [:meier, :maier], :P360 => [:peter] }
+  #   end
+  # end
+
+  # context 'integration' do
+  #   it 'should return the right ordered array' do
+  #     index = @similarity.generate_from :meier => nil, :maier => nil, :mairai => nil, :mair => nil, :meira => nil
+  #     code  = @similarity.encoded :maier
+  #
+  #     index[code].should == [:mair, :maier, :meier, :meira, :mairai]
+  #   end
+  # end
 
 end

data/spec/lib/generators/weights/constant_spec.rb

@@ -0,0 +1,37 @@
+require 'spec_helper'
+
+describe Picky::Generators::Weights::Constant do
+
+  context 'default weight' do
+    let(:constant) { described_class.new }
+
+    describe '[]' do
+      it 'is always 0.0' do
+        constant[:whatevs].should == 0.0
+      end
+    end
+
+    describe 'weight_for' do
+      it 'is 0.0' do
+        constant.weight_for(1234).should == 0.0
+      end
+    end
+  end
+
+  context 'defined weight' do
+    let(:constant) { described_class.new 3.14 }
+
+    describe '[]' do
+      it 'is always the defined weight' do
+        constant[:whatevs].should == 3.14
+      end
+    end
+
+    describe 'weight_for' do
+      it 'is always the defined weight' do
+        constant.weight_for(1234).should == 3.14
+      end
+    end
+  end
+
+end

data/spec/lib/generators/weights/dynamic_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Picky::Generators::Weights::Dynamic do
+
+  context 'defined block' do
+    let(:constant) { described_class.new { |str_or_sym| str_or_sym.size } }
+
+    describe '[]' do
+      it 'is the length of the given string' do
+        constant[''].should == 0
+      end
+      it 'is the length of the given string' do
+        constant['whatevs'].should == 7
+      end
+      it 'is the length of the given symbol' do
+        constant[:whatever].should == 8
+      end
+    end
+
+    describe 'weight_for' do
+      it 'is nil' do
+        constant.weight_for(1234).should == nil
+      end
+    end
+  end
+
+end

data/spec/lib/generators/weights/logarithmic_spec.rb

@@ -2,28 +2,23 @@ require 'spec_helper'
 
 describe Picky::Generators::Weights::Logarithmic do
 
-  before(:each) do
-    @cacher = described_class.new
-  end
+  let(:logarithmic) { described_class.new }
 
-  describe 'generate_from' do
-    it 'should not fail on empties' do
-      @cacher.generate_from({ :key => [] }).should == { :key => 0 }
-    end
-    it 'should round to 2' do
-      @cacher.generate_from({ :key => [1,2,3,4] }).should == { :key => 1.39 }
+  describe 'saved?' do
+    it 'is correct' do
+      logarithmic.saved?.should == true
     end
   end
 
   describe 'weight_for' do
-    it 'should be 0 for 0' do
-      @cacher.weight_for(0).should == 0
+    it 'is 0 for 0' do
+      logarithmic.weight_for(0).should == 0
     end
-    it 'should be 0 for 1' do
-      @cacher.weight_for(1).should == 0
+    it 'is 0 for 1' do
+      logarithmic.weight_for(1).should == 0
     end
-    it 'should be log(x) for x' do
-      @cacher.weight_for(1234).should == Math.log(1234)
+    it 'is log(x) for x' do
+      logarithmic.weight_for(1234).should == Math.log(1234)
     end
   end
 

data/spec/lib/indexed/bundle_spec.rb

@@ -6,7 +6,7 @@ describe Picky::Bundle do
     @index        = Picky::Index.new :some_index
     @category     = Picky::Category.new :some_category, @index
 
-    @weights      = stub :weights
+    @weights      = stub :weights, :saved? => true
     @partial      = stub :partial
     @similarity   = stub :similarity
     @bundle       = described_class.new :some_name, @category, Picky::Backends::Memory.new, @weights, @partial, @similarity
@@ -158,7 +158,8 @@ describe Picky::Bundle do
       @index    = Picky::Index.new :some_index
       @category = Picky::Category.new :some_category, @index
 
-      @bundle = described_class.new :some_name, @category, Picky::Backends::Memory.new, :weights, :partial, :similarity
+      @weights = stub :weights, :saved? => true
+      @bundle = described_class.new :some_name, @category, Picky::Backends::Memory.new, @weights, :partial, :similarity
     end
     it 'should initialize the index correctly' do
       @bundle.backend_inverted.should be_kind_of(Picky::Backends::Memory::JSON)

data/spec/lib/indexed/wrappers/bundle/calculation_spec.rb

@@ -9,27 +9,27 @@ describe Picky::Wrappers::Bundle::Calculation do
 
   describe 'ids' do
     it 'calls bundle#ids correctly' do
-      @bundle.should_receive(:ids).once.with :'0.0'
+      @bundle.should_receive(:ids).once.with '0.0'
 
-      @calculation.ids :some_sym
+      @calculation.ids 'some_str'
     end
     it 'calls bundle#ids correctly' do
-      @bundle.should_receive(:ids).once.with :'6.28'
+      @bundle.should_receive(:ids).once.with '6.28'
 
-      @calculation.ids :'6.28'
+      @calculation.ids '6.28'
     end
   end
 
   describe 'weight' do
     it 'calls bundle#ids correctly' do
-      @bundle.should_receive(:weight).once.with :'0.0'
+      @bundle.should_receive(:weight).once.with '0.0'
 
-      @calculation.weight :some_sym
+      @calculation.weight 'some_str'
     end
     it 'calls bundle#ids correctly' do
-      @bundle.should_receive(:weight).once.with :'6.28'
+      @bundle.should_receive(:weight).once.with '6.28'
 
-      @calculation.weight :'6.28'
+      @calculation.weight '6.28'
     end
   end
 

data/spec/lib/indexing/bundle_spec.rb

@@ -5,9 +5,10 @@ describe Picky::Bundle do
   before(:each) do
     @index    = Picky::Index.new :some_index
     @category = Picky::Category.new :some_category, @index
+    @weights    = Picky::Weights::Logarithmic.new
     @similarity = Picky::Similarity::DoubleMetaphone.new 3
   end
-  let(:bundle) { described_class.new :some_name, @category, Picky::Backends::Memory.new, :some_weights, :some_partial, @similarity }
+  let(:bundle) { described_class.new :some_name, @category, Picky::Backends::Memory.new, @weights, :some_partial, @similarity }
 
   describe 'identifier' do
     it 'is correct' do
@@ -17,13 +18,14 @@ describe Picky::Bundle do
 
   describe 'similar' do
     before(:each) do
-      bundle.similarity = @similarity.generate_from( :dragon => [1,2,3], :dargon => [4,5,6] )
+      bundle.add_similarity :dragon
+      bundle.add_similarity :dargon
     end
     it 'returns the right similars (not itself)' do
       bundle.similar(:dragon).should == [:dargon]
     end
     it 'returns the right similars' do
-      bundle.similar(:trkn).should == [:dragon, :dargon]
+      bundle.similar(:trkn).should == [:dargon, :dragon]
     end
     it 'performs' do
       performance_of { bundle.similar(:dragon) }.should < 0.000075

data/spec/specific/dynamic_weights_spec.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe "Weights" do
+
+  # This tests the weights option.
+  #
+  context 'various cases' do
+    it 'stopwords destroy ids (final: id reference on attribute)' do
+      index = Picky::Index.new :dynamic_weights do
+        source { [] }
+        category :text1, weights: Picky::Weights::Constant.new
+        category :text2, weights: Picky::Weights::Constant.new(3.14)
+        category :text3, weights: Picky::Weights::Dynamic.new { |str_or_sym| str_or_sym.size }
+        category :text4 # Default
+      end
+
+      require 'ostruct'
+
+      thing = OpenStruct.new id: 1, text1: "ohai", text2: "hello", text3: "world", text4: "kthxbye"
+      other = OpenStruct.new id: 2, text1: "",     text2: "",      text3: "",      text4: "kthxbye"
+
+      index.add thing
+      index.add other
+
+      try = Picky::Search.new index
+
+      try.search("text1:ohai").allocations.first.score.should    == 0.0
+      try.search("text2:hello").allocations.first.score.should   == 3.14
+      try.search("text3:world").allocations.first.score.should   == 5
+      try.search("text4:kthxbye").allocations.first.score.should == 0.6931471805599453
+
+      try_with_boosts = Picky::Search.new index do
+        boost [:text1] => +7.65,
+              [:text2] => +1.86
+      end
+
+      try_with_boosts.search("text1:ohai").allocations.first.score.should  == 7.65
+      try_with_boosts.search("text2:hello").allocations.first.score.should == 5.00
+    end
+  end
+
+end