picky 3.5.0 → 3.5.1

data/lib/picky/loader.rb

@@ -91,6 +91,9 @@ module Picky
       # Weight index generation strategies.
       #
       load_relative 'generators/weights/strategy'
+      load_relative 'generators/weights/runtime'
+      load_relative 'generators/weights/dynamic'
+      load_relative 'generators/weights/constant'
       load_relative 'generators/weights/logarithmic'
       load_relative 'generators/weights/default'
 
@@ -143,9 +146,6 @@ module Picky
       load_relative 'wrappers/bundle/location'
       load_relative 'wrappers/bundle/exact_partial'
 
-      # load_relative 'wrappers/sources/base'
-      # load_relative 'wrappers/sources/location'
-
       # Tokens.
       #
       load_relative 'query/token'

data/lib/picky/query/allocations.rb

@@ -9,8 +9,9 @@ module Picky
       attr_reader :total
 
       delegate :each,
-               :inject,
                :empty?,
+               :first,
+               :inject,
                :size,
                :to => :@allocations
 

data/lib/picky/query/tokens.rb

@@ -27,16 +27,6 @@ module Picky
         new words.zip(originals).collect! { |word, original| Token.processed word, original }, ignore_unassigned
       end
 
-      # Tokenizes each token.
-      #
-      # Note: Passed tokenizer needs to offer #normalize(text).
-      #
-      # TODO Still needed?
-      #
-      def tokenize_with tokenizer
-        @tokens.each { |token| token.tokenize_with(tokenizer) }
-      end
-
       # Generates an array in the form of
       # [
       #  [combination],                           # of token 1

data/spec/lib/category_indexed_spec.rb

@@ -7,7 +7,7 @@ describe Picky::Category do
       source []
     end
     @partial_strategy    = stub :partial, :use_exact_for_partial? => false
-    @weights_strategy    = stub :weights
+    @weights_strategy    = stub :weights, :saved? => true
     @similarity_strategy = stub :similarity
 
     @exact   = stub :exact, :dump => nil

data/spec/lib/character_substituters/west_european_spec.rb

@@ -3,41 +3,39 @@
 require 'spec_helper'
 
 describe Picky::CharacterSubstituters::WestEuropean do
-  
-  before(:all) do
-    @substituter = described_class.new.tap { |s| s.substitute '' }
-  end
+
+  let(:substituter) { described_class.new.tap { |s| s.substitute '' } }
 
   # A bit of metaprogramming to help with the myriads of its.
   #
   def self.it_should_substitute special_character, normal_character
     it "should substitute #{special_character} with #{normal_character}" do
-      @substituter.substitute(special_character).should == normal_character
+      substituter.substitute(special_character).should == normal_character
     end
   end
-  def self.it_should_not_substitute special_character 
+  def self.it_should_not_substitute special_character
     it "should not substitute #{special_character}" do
-      @substituter.substitute(special_character).should == special_character
+      substituter.substitute(special_character).should == special_character
     end
   end
-  
+
   # Speed spec at the top since the order of the describes made the
   # speed spec trip. And not on mushrooms either.
   #
   describe "speed" do
     it "is fast" do
-      result = performance_of { @substituter.substitute('ä') }
+      result = performance_of { substituter.substitute('ä') }
       result.should < 0.00009
     end
     it "is fast" do
-      result = performance_of { @substituter.substitute('abcdefghijklmnopqrstuvwxyz1234567890') }
+      result = performance_of { substituter.substitute('abcdefghijklmnopqrstuvwxyz1234567890') }
       result.should < 0.00015
     end
   end
-  
+
   describe 'to_s' do
     it 'outputs correctly' do
-      @substituter.to_s.should == 'Picky::CharacterSubstituters::WestEuropean'
+      substituter.to_s.should == 'Picky::CharacterSubstituters::WestEuropean'
     end
   end
 
@@ -108,7 +106,7 @@ describe Picky::CharacterSubstituters::WestEuropean do
     it_should_substitute 'å', 'a'
     it_should_substitute 'Å', 'A'
   end
-  
+
   describe "diacritic" do
     it_should_substitute 'ñ', 'n'
   end

data/spec/lib/generators/partial/infix_spec.rb

@@ -15,100 +15,100 @@ describe Picky::Generators::Partial::Infix do
         generator.min.should == 1
       end
     end
-    describe 'generate_from' do
-      it 'should generate the right index' do
-        generator.generate_from(florian: [1], flavia: [2]).should == {
-          florian: [1],
-          floria:  [1],
-          lorian:  [1],
-          flori:   [1],
-          loria:   [1],
-          orian:   [1],
-          flor:    [1],
-          lori:    [1],
-          oria:    [1],
-          rian:    [1],
-          flo:     [1],
-          lor:     [1],
-          ori:     [1],
-          ria:     [1],
-          ian:     [1],
-          fl:   [1, 2],
-          lo:      [1],
-          or:      [1],
-          ri:      [1],
-          ia:   [1, 2],
-          an:      [1],
-          f:    [1, 2],
-          l:    [1, 2],
-          o:       [1],
-          r:       [1],
-          i:    [1, 2],
-          a:    [1, 2],
-          n:       [1],
-          flavia:  [2],
-          flavi:   [2],
-          lavia:   [2],
-          flav:    [2],
-          lavi:    [2],
-          avia:    [2],
-          fla:     [2],
-          lav:     [2],
-          avi:     [2],
-          via:     [2],
-          la:      [2],
-          av:      [2],
-          vi:      [2],
-          v:       [2]
-        }
-      end
-      it "should be fast" do
-        performance_of { generator.generate_from(florian: [1], flavia: [2]) }.should < 0.0001
-      end
-      it "should handle duplicate ids" do
-        generator.generate_from(flo: [1], fla: [1]).should == {
-          flo: [1],
-          fl:  [1],
-          lo:  [1],
-          f:   [1],
-          l:   [1],
-          o:   [1],
-          a:   [1],
-          fla: [1],
-          la:  [1],
-        }
-      end
-    end
+    # describe 'generate_from' do
+    #   it 'should generate the right index' do
+    #     generator.generate_from(florian: [1], flavia: [2]).should == {
+    #       florian: [1],
+    #       floria:  [1],
+    #       lorian:  [1],
+    #       flori:   [1],
+    #       loria:   [1],
+    #       orian:   [1],
+    #       flor:    [1],
+    #       lori:    [1],
+    #       oria:    [1],
+    #       rian:    [1],
+    #       flo:     [1],
+    #       lor:     [1],
+    #       ori:     [1],
+    #       ria:     [1],
+    #       ian:     [1],
+    #       fl:   [1, 2],
+    #       lo:      [1],
+    #       or:      [1],
+    #       ri:      [1],
+    #       ia:   [1, 2],
+    #       an:      [1],
+    #       f:    [1, 2],
+    #       l:    [1, 2],
+    #       o:       [1],
+    #       r:       [1],
+    #       i:    [1, 2],
+    #       a:    [1, 2],
+    #       n:       [1],
+    #       flavia:  [2],
+    #       flavi:   [2],
+    #       lavia:   [2],
+    #       flav:    [2],
+    #       lavi:    [2],
+    #       avia:    [2],
+    #       fla:     [2],
+    #       lav:     [2],
+    #       avi:     [2],
+    #       via:     [2],
+    #       la:      [2],
+    #       av:      [2],
+    #       vi:      [2],
+    #       v:       [2]
+    #     }
+    #   end
+    #   it "should be fast" do
+    #     performance_of { generator.generate_from(florian: [1], flavia: [2]) }.should < 0.0001
+    #   end
+    #   it "should handle duplicate ids" do
+    #     generator.generate_from(flo: [1], fla: [1]).should == {
+    #       flo: [1],
+    #       fl:  [1],
+    #       lo:  [1],
+    #       f:   [1],
+    #       l:   [1],
+    #       o:   [1],
+    #       a:   [1],
+    #       fla: [1],
+    #       la:  [1],
+    #     }
+    #   end
+    # end
   end
   context 'from set' do
-    describe 'negative min' do
-      before(:each) do
-        @generator = described_class.new min: -2
-      end
-      it 'should generate the right index' do
-        @generator.generate_from(florian: [1], flavia: [2]).should == {
-          :florian => [1],
-          :floria  => [1],
-          :lorian  => [1],
-          :flavia  => [2],
-          :flavi   => [2],
-          :lavia   => [2]
-        }
-      end
-    end
+    # describe 'negative min' do
+    #   before(:each) do
+    #     @generator = described_class.new min: -2
+    #   end
+    #   it 'should generate the right index' do
+    #     @generator.generate_from(florian: [1], flavia: [2]).should == {
+    #       :florian => [1],
+    #       :floria  => [1],
+    #       :lorian  => [1],
+    #       :flavia  => [2],
+    #       :flavi   => [2],
+    #       :lavia   => [2]
+    #     }
+    #   end
+    # end
     context "large min" do
       before(:each) do
         @generator = described_class.new min: 10
       end
-      describe 'generate_from' do
-        it 'should generate the right index' do
-          @generator.generate_from(florian: [1], :'01234567890' => [2]).should == {
-            :'01234567890' => [2],
-            :'0123456789' => [2],
-            :'1234567890' => [2]
-          }
-        end
-      end
+      # describe 'generate_from' do
+      #   it 'should generate the right index' do
+      #     @generator.generate_from(florian: [1], :'01234567890' => [2]).should == {
+      #       :'01234567890' => [2],
+      #       :'0123456789' => [2],
+      #       :'1234567890' => [2]
+      #     }
+      #   end
+      # end
     end
     context 'default max' do
       before(:each) do
@@ -124,54 +124,54 @@ describe Picky::Generators::Partial::Infix do
           @generator.min.should == 4
         end
       end
-      describe 'generate_from' do
-        it 'should generate the right index' do
-          @generator.generate_from( :florian => [1], :flavia => [2] ).should == {
-            :florian => [1],
-            :floria  => [1],
-            :lorian  => [1],
-            :flori   => [1],
-            :loria   => [1],
-            :orian   => [1],
-            :flor    => [1],
-            :lori    => [1],
-            :oria    => [1],
-            :rian    => [1],
-            :flavia  => [2],
-            :flavi   => [2],
-            :lavia   => [2],
-            :flav    => [2],
-            :lavi    => [2],
-            :avia    => [2]
-          }
-        end
-      end
-      describe "a bigger example with disjunct symbols" do
-        before(:each) do
-          abc = ('A'..'Z').to_a + ('a'..'z').to_a
-          @index = {}
-          52.times do |i|
-            @index[abc.join.to_sym] = [i]
-            character = abc.shift
-            abc << character
-          end
-        end
-        it "should be fast" do
-          performance_of { @generator.generate_from(@index) }.should < 0.07
-        end
-      end
-      describe "a bigger example with almost identical symbols" do
-        before(:each) do
-          abc = ('A'..'Z').to_a + ('a'..'z').to_a
-          @index = {}
-          52.times do |i|
-            @index[(abc.join + abc[i].to_s).to_sym] = [i]
-          end
-        end
-        it "should be fast" do
-          performance_of { @generator.generate_from(@index) }.should < 0.07
-        end
-      end
+      # describe 'generate_from' do
+      #   it 'should generate the right index' do
+      #     @generator.generate_from( :florian => [1], :flavia => [2] ).should == {
+      #       :florian => [1],
+      #       :floria  => [1],
+      #       :lorian  => [1],
+      #       :flori   => [1],
+      #       :loria   => [1],
+      #       :orian   => [1],
+      #       :flor    => [1],
+      #       :lori    => [1],
+      #       :oria    => [1],
+      #       :rian    => [1],
+      #       :flavia  => [2],
+      #       :flavi   => [2],
+      #       :lavia   => [2],
+      #       :flav    => [2],
+      #       :lavi    => [2],
+      #       :avia    => [2]
+      #     }
+      #   end
+      # end
+      # describe "a bigger example with disjunct symbols" do
+      #   before(:each) do
+      #     abc = ('A'..'Z').to_a + ('a'..'z').to_a
+      #     @index = {}
+      #     52.times do |i|
+      #       @index[abc.join.to_sym] = [i]
+      #       character = abc.shift
+      #       abc << character
+      #     end
+      #   end
+      #   it "should be fast" do
+      #     performance_of { @generator.generate_from(@index) }.should < 0.07
+      #   end
+      # end
+      # describe "a bigger example with almost identical symbols" do
+      #   before(:each) do
+      #     abc = ('A'..'Z').to_a + ('a'..'z').to_a
+      #     @index = {}
+      #     52.times do |i|
+      #       @index[(abc.join + abc[i].to_s).to_sym] = [i]
+      #     end
+      #   end
+      #   it "should be fast" do
+      #     performance_of { @generator.generate_from(@index) }.should < 0.07
+      #   end
+      # end
     end
     context 'to set' do
       before(:each) do
@@ -187,26 +187,26 @@ describe Picky::Generators::Partial::Infix do
           @generator.min.should == 4
         end
       end
-      describe 'generate_from' do
-        it 'should generate the right index' do
-          @generator.generate_from( :florian => [1], :flavia => [2] ).should == {
-            :floria => [1],
-            :lorian => [1],
-            :flori  => [1],
-            :loria  => [1],
-            :orian  => [1],
-            :flor   => [1],
-            :lori   => [1],
-            :oria   => [1],
-            :rian   => [1],
-            :flavi  => [2],
-            :lavia  => [2],
-            :flav   => [2],
-            :lavi   => [2],
-            :avia   => [2]
-          }
-        end
-      end
+      # describe 'generate_from' do
+      #   it 'should generate the right index' do
+      #     @generator.generate_from( :florian => [1], :flavia => [2] ).should == {
+      #       :floria => [1],
+      #       :lorian => [1],
+      #       :flori  => [1],
+      #       :loria  => [1],
+      #       :orian  => [1],
+      #       :flor   => [1],
+      #       :lori   => [1],
+      #       :oria   => [1],
+      #       :rian   => [1],
+      #       :flavi  => [2],
+      #       :lavia  => [2],
+      #       :flav   => [2],
+      #       :lavi   => [2],
+      #       :avia   => [2]
+      #     }
+      #   end
+      # end
     end
     context 'min/max set' do
       before(:each) do
@@ -222,11 +222,11 @@ describe Picky::Generators::Partial::Infix do
           @generator.min.should == 4
         end
       end
-      describe 'generate_from' do
-        it 'should generate the right index' do
-          @generator.generate_from( :florian => [1], :flavia => [2] ).should == {}
-        end
-      end
+      # describe 'generate_from' do
+      #   it 'should generate the right index' do
+      #     @generator.generate_from( :florian => [1], :flavia => [2] ).should == {}
+      #   end
+      # end
     end
   end
 

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

@@ -8,9 +8,9 @@ describe Picky::Generators::Partial::None do
   it "has the right superclass" do
     described_class.should < Picky::Generators::Partial::Strategy
   end
-  it "returns an empty index" do
-    described_class.new.generate_from(:unimportant).should == {}
-  end
+  # it "returns an empty index" do
+  #   described_class.new.generate_from(:unimportant).should == {}
+  # end
   describe 'use_exact_for_partial?' do
     it 'returns true' do
       described_class.new.use_exact_for_partial?.should == true