picky 3.1.0 → 3.1.1

data/lib/picky/generators/partial/infix.rb

@@ -0,0 +1,93 @@
+module Picky
+
+  module Generators
+
+    module Partial
+
+      # The subtoken partial strategy.
+      #
+      # If given "florian"
+      # it will index "floria", "flori", "flor", "flo", "fl", "f"
+      # (Depending on what the given from value is, the example is with option from: 1)
+      #
+      class Infix < Strategy
+
+        attr_reader :min,
+                    :max
+
+        # The min option signifies with what size it
+        # will start in generating the infix tokens.
+        #
+        # Examples:
+        #
+        # With :hello, and max: -1 (default)
+        # * min: 1 # => [:hello, :hell, :ello, :hel, :ell, :llo, :he, :el, :ll, :lo, :h, :e, :l, :l, :o]
+        # * min: 4 # => [:hello, :hell, :ello]
+        #
+        # With :hello, and max: -2
+        # * min: 1 # => [:hell, :ello, :hel, :ell, :llo, :he, :el, :ll, :lo, :h, :e, :l, :l, :o]
+        # * min: 4 # => [:hell, :ello]
+        #
+        # (min 1 is default)
+        #
+        def initialize options = {}
+          @min = options[:min] || 1
+          @max = options[:max] || -1
+        end
+
+        # Generates a partial index from the given inverted index.
+        #
+        def generate_from inverted
+          result = {}
+
+          # Generate for each key token the subtokens.
+          #
+          i = 0
+          j = 0
+          inverted.each_key do |token|
+            i += 1
+            if i == 5000
+              j += 1
+              timed_exclaim %Q{#{"%8i" % (i*j)} generated (current token: "#{token}").}
+              i = 0
+            end
+            generate_for token, inverted, result
+          end
+
+          # Remove duplicate ids.
+          #
+          # THINK If it is unique for a subtoken, it is
+          #       unique for all derived longer tokens.
+          #
+          result.each_value &:uniq!
+
+          result
+        end
+
+        private
+
+          # To each shortened token of :test
+          # :test, :tes, :te, :t
+          # add all ids of :test
+          #
+          # "token" here means just text.
+          #
+          # THINK Could be improved by appending the aforegoing ids?
+          #
+          def generate_for token, inverted, result
+            token.each_intoken(min, max) do |intoken|
+              if result[intoken]
+                result[intoken] += inverted[token] # unique
+              else
+                result[intoken] = inverted[token].dup
+              end
+            end
+          end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/picky/generators/partial/substring.rb

@@ -49,8 +49,8 @@ module Picky
         # * from: 4 # => [:hell]
         #
         def initialize options = {}
-          from     = options[:from] || 1
-          to = options[:to] || -1
+          from = options[:from] || 1
+          to   = options[:to]   || -1
           @generator = SubstringGenerator.new from, to
         end
 

data/lib/picky/indexes_indexing.rb

@@ -35,6 +35,8 @@ module Picky
     # For integration testing – indexes for the tests
     # without forking and shouting ;)
     #
+    # TODO Rename to #index_without_forking, or just #index.
+    #
     def index_for_tests
       indexes.each(&:index)
     end

data/lib/picky/indexing/bundle.rb

@@ -46,7 +46,7 @@ module Picky
         @weights_strategy = weights_strategy
         @partial_strategy = partial_strategy
         @key_format       = options[:key_format]
-        @prepared         = Backends::File::Text.new category.prepared_index_path
+        @prepared         = Backends::Memory::Text.new category.prepared_index_path
 
         @inverted      = {}
         @weights       = {}

data/lib/picky/loader.rb

@@ -83,6 +83,7 @@ module Picky
       load_relative 'generators/partial/strategy'
       load_relative 'generators/partial/none'
       load_relative 'generators/partial/substring'
+      load_relative 'generators/partial/infix'
       load_relative 'generators/partial/default'
 
       # Weight index generation strategies.
@@ -114,15 +115,19 @@ module Picky
 
       load_relative 'backends/redis'
       load_relative 'backends/redis/basic'
-      load_relative 'backends/redis/list_hash'
-      load_relative 'backends/redis/string_hash'
-      load_relative 'backends/redis/float_hash'
+      load_relative 'backends/redis/list'
+      load_relative 'backends/redis/string'
+      load_relative 'backends/redis/float'
 
+      load_relative 'backends/memory'
+      load_relative 'backends/memory/basic'
+      load_relative 'backends/memory/text'
+      load_relative 'backends/memory/marshal'
+      load_relative 'backends/memory/json'
+
+      load_relative 'backends/file'
       load_relative 'backends/file/basic'
-      load_relative 'backends/file/text'
-      load_relative 'backends/file/marshal'
       load_relative 'backends/file/json'
-      load_relative 'backends/memory'
 
       # Indexing and Indexed things.
       #

data/lib/picky/migrations/from_30_to_31.rb

@@ -31,7 +31,7 @@ MESSAGE
     class Redis
 
       def initialize(*)
-        raise <<-RAISE
+        raise <<-MESSAGE
 
 The Picky::Indexes::Redis is not available anymore and has been replaced by Picky::Index.
 (with the addition of a "backend" option)
@@ -51,7 +51,7 @@ use
 
 Thanks and sorry for the inconvenience!
 
-RAISE
+MESSAGE
       end
 
     end

data/lib/picky/query/allocation.rb

@@ -38,6 +38,7 @@ module Picky
       # Asks the backend for the (intersected) ids.
       #
       def calculate_ids amount, offset
+        return [] if combinations.empty?
         @backend.ids combinations, amount, offset
       end
 

data/lib/picky/query/combinations.rb

@@ -13,7 +13,9 @@ module Picky
 
       attr_reader :combinations
 
-      delegate :empty?, :inject, :to => :@combinations
+      delegate :empty?,
+               :inject,
+               :to => :@combinations
 
       def initialize combinations = []
         @combinations = combinations

data/spec/lib/backends/{file → memory}/basic_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 
-describe Picky::Backends::File::Basic do
+describe Picky::Backends::Memory::Basic do
   
   let(:file) { described_class.new 'some/cache/path/to/file' }
   
   describe 'backup_file_path_of' do
     it 'returns a backup path relative to the path' do
-      file.backup_file_path_of('some/path/to/some.index').should == 'some/path/to/backup/some.index'
+      file.backup_file_path_of('some/path/to/some.memory.index').should == 'some/path/to/backup/some.memory.index'
     end
   end
   
@@ -18,7 +18,7 @@ describe Picky::Backends::File::Basic do
   
   describe 'to_s' do
     it 'returns the cache path with the default file extension' do
-      file.to_s.should == 'Picky::Backends::File::Basic(some/cache/path/to/file.index)'
+      file.to_s.should == 'Picky::Backends::Memory::Basic(some/cache/path/to/file.memory.index)'
     end
   end
   

data/spec/lib/backends/{file → memory}/json_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Picky::Backends::File::JSON do
+describe Picky::Backends::Memory::JSON do
   
   let(:file) { described_class.new 'some/cache/path/to/file' }
   
@@ -8,7 +8,7 @@ describe Picky::Backends::File::JSON do
     it "delegates to the given hash" do
       hash = stub :hash
       
-      hash.should_receive(:dump_json).once.with "some/cache/path/to/file.json"
+      hash.should_receive(:dump_json).once.with "some/cache/path/to/file.memory.json"
       
       file.dump hash
     end
@@ -24,7 +24,7 @@ describe Picky::Backends::File::JSON do
   
   describe 'to_s' do
     it 'returns the cache path with the default file extension' do
-      file.to_s.should == 'Picky::Backends::File::JSON(some/cache/path/to/file.json)'
+      file.to_s.should == 'Picky::Backends::Memory::JSON(some/cache/path/to/file.memory.json)'
     end
   end
   

data/spec/lib/backends/{file → memory}/marshal_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Picky::Backends::File::Marshal do
+describe Picky::Backends::Memory::Marshal do
   
   let(:file) { described_class.new 'some/cache/path/to/file' }
   
@@ -8,7 +8,7 @@ describe Picky::Backends::File::Marshal do
     it "delegates to the given hash" do
       hash = stub :hash
       
-      hash.should_receive(:dump_marshal).once.with "some/cache/path/to/file.dump"
+      hash.should_receive(:dump_marshal).once.with "some/cache/path/to/file.memory.dump"
       
       file.dump hash
     end
@@ -24,7 +24,7 @@ describe Picky::Backends::File::Marshal do
   
   describe 'to_s' do
     it 'returns the cache path with the default file extension' do
-      file.to_s.should == 'Picky::Backends::File::Marshal(some/cache/path/to/file.dump)'
+      file.to_s.should == 'Picky::Backends::Memory::Marshal(some/cache/path/to/file.memory.dump)'
     end
   end
   

data/spec/lib/backends/{file → memory}/text_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Picky::Backends::File::Text do
+describe Picky::Backends::Memory::Text do
   
   before(:each) do
     @file = described_class.new "some_cache_path"

data/spec/lib/backends/memory_spec.rb

@@ -10,10 +10,10 @@ describe Picky::Backends::Memory do
   
   describe 'create_...' do
     [
-      [:inverted,      Picky::Backends::File::JSON],
-      [:weights,       Picky::Backends::File::JSON],
-      [:similarity,    Picky::Backends::File::Marshal],
-      [:configuration, Picky::Backends::File::JSON]
+      [:inverted,      Picky::Backends::Memory::JSON],
+      [:weights,       Picky::Backends::Memory::JSON],
+      [:similarity,    Picky::Backends::Memory::Marshal],
+      [:configuration, Picky::Backends::Memory::JSON]
     ].each do |type, kind|
       it "creates and returns a(n) #{type} index" do
         @backend.send(:"create_#{type}",

data/spec/lib/backends/redis/{float_hash_spec.rb → float_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Picky::Backends::Redis::FloatHash do
+describe Picky::Backends::Redis::Float do
   
   let(:client) { stub :client }
   let(:backend) { described_class.new client, :some_namespace }
@@ -31,7 +31,7 @@ describe Picky::Backends::Redis::FloatHash do
   
   describe 'to_s' do
     it 'returns the cache path with the default file extension' do
-      backend.to_s.should == 'Picky::Backends::Redis::FloatHash(some_namespace:*)'
+      backend.to_s.should == 'Picky::Backends::Redis::Float(some_namespace:*)'
     end
   end
   

data/spec/lib/backends/redis/{list_hash_spec.rb → list_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Picky::Backends::Redis::ListHash do
+describe Picky::Backends::Redis::List do
   
   let(:client) { stub :client }
   let(:index) { described_class.new client, :some_namespace }
@@ -20,7 +20,7 @@ describe Picky::Backends::Redis::ListHash do
   
   describe 'to_s' do
     it 'returns the cache path with the default file extension' do
-      index.to_s.should == 'Picky::Backends::Redis::ListHash(some_namespace:*)'
+      index.to_s.should == 'Picky::Backends::Redis::List(some_namespace:*)'
     end
   end
   

data/spec/lib/backends/redis/{string_hash_spec.rb → string_spec.rb}

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Picky::Backends::Redis::StringHash do
+describe Picky::Backends::Redis::String do
   
   let(:client) { stub :client }
   let(:backend) { described_class.new client, :some_namespace }
@@ -31,7 +31,7 @@ describe Picky::Backends::Redis::StringHash do
   
   describe 'to_s' do
     it 'returns the cache path with the default file extension' do
-      backend.to_s.should == 'Picky::Backends::Redis::StringHash(some_namespace:*)'
+      backend.to_s.should == 'Picky::Backends::Redis::String(some_namespace:*)'
     end
   end
   

data/spec/lib/backends/redis_spec.rb

@@ -10,10 +10,10 @@ describe Picky::Backends::Redis do
   
   describe 'create_...' do
     [
-      [:inverted,      Picky::Backends::Redis::ListHash],
-      [:weights,       Picky::Backends::Redis::FloatHash],
-      [:similarity,    Picky::Backends::Redis::ListHash],
-      [:configuration, Picky::Backends::Redis::StringHash]
+      [:inverted,      Picky::Backends::Redis::List],
+      [:weights,       Picky::Backends::Redis::Float],
+      [:similarity,    Picky::Backends::Redis::List],
+      [:configuration, Picky::Backends::Redis::String]
     ].each do |type, kind|
       it "creates and returns a(n) #{type} index" do
         @backend.send(:"create_#{type}",

data/spec/lib/bundle_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe Picky::Bundle do
+
+  before(:each) do
+    @index    = Picky::Index.new :some_index
+    @category = Picky::Category.new :some_category, @index
+    @similarity = Picky::Similarity::DoubleMetaphone.new 3
+  end
+  let(:bundle) { described_class.new :some_name, @category, Picky::Backends::Memory.new, @similarity }
+  
+  describe 'identifier' do
+    it 'is correct' do
+      bundle.identifier.should == 'test:some_index:some_category:some_name'
+    end
+  end
+  
+  describe 'index_path' do
+    it 'is correct' do
+      bundle.index_path(:some_type).should == 'spec/test_directory/index/test/some_index/some_category_some_name_some_type'
+    end
+    it 'is correct' do
+      bundle.index_path.should == 'spec/test_directory/index/test/some_index/some_category_some_name'
+    end
+  end
+  
+end

data/spec/lib/extensions/symbol_spec.rb

@@ -9,9 +9,245 @@ describe Symbol do
     before(:each) do
       @token = (((0..9).to_a)*10).to_s.to_sym
     end
-    it "should be fast" do
+    it "is fast" do
       performance_of { @token.each_subtoken { |subtoken| } }.should < 0.00065
     end
+    it 'is fast enough' do
+      performance_of { @token.each_intoken { |intoken| } }.should < 0.025 # TODO Slow!
+    end
+  end
+  
+  describe 'each_intoken' do
+    context 'normal symbol' do
+      before(:each) do
+        @sym = :picky
+      end
+      context 'no params' do
+        it "yields the right elements" do
+          result = []
+          @sym.each_intoken do |subtoken|
+            result << subtoken
+          end
+          result.should == [:picky, :pick, :icky, :pic, :ick, :cky, :pi, :ic, :ck, :ky, :p, :i, :c, :k, :y]
+        end
+      end
+      context 'with min_length == 0' do
+        it "yields the right elements" do
+          result = []
+          @sym.each_intoken(0) do |subtoken|
+            result << subtoken
+          end
+          result.should == [:picky, :pick, :icky, :pic, :ick, :cky, :pi, :ic, :ck, :ky, :p, :i, :c, :k, :y]
+        end
+        context 'max_length == 0' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(0, 0) do |subtoken|
+              result << subtoken
+            end
+            result.should == [:p, :i, :c, :k, :y]
+          end
+        end
+        context 'max_length == 1' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(0, 1) do |subtoken|
+              result << subtoken
+            end
+            result.should == [:p, :i, :c, :k, :y]
+          end
+        end
+        context 'max_length == 2' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(0, 2) do |subtoken|
+              result << subtoken
+            end
+            result.should == [:pi, :ic, :ck, :ky, :p, :i, :c, :k, :y]
+          end
+        end
+        context 'max_length == 10' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(0, 10) do |subtoken|
+              result << subtoken
+            end
+            result.should == [:picky, :pick, :icky, :pic, :ick, :cky, :pi, :ic, :ck, :ky, :p, :i, :c, :k, :y]
+          end
+        end
+        context 'max_length == -1' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(0, -1) do |subtoken|
+              result << subtoken
+            end
+            result.should == [:picky, :pick, :icky, :pic, :ick, :cky, :pi, :ic, :ck, :ky, :p, :i, :c, :k, :y]
+          end
+        end
+      end
+      context 'with min_length == sym.size' do
+        it "yields the right elements" do
+          result = []
+          @sym.each_intoken(@sym.size) do |subtoken|
+            result << subtoken
+          end
+          result.should == [:picky]
+        end
+        context 'max_length == 0' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(@sym.size, 0) do |subtoken|
+              result << subtoken
+            end
+            result.should == []
+          end
+        end
+        context 'max_length == 1' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(@sym.size, 1) do |subtoken|
+              result << subtoken
+            end
+            result.should == []
+          end
+        end
+        context 'max_length == 2' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(@sym.size, 2) do |subtoken|
+              result << subtoken
+            end
+            result.should == []
+          end
+        end
+        context 'max_length == 10' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(@sym.size, 10) do |subtoken|
+              result << subtoken
+            end
+            result.should == [:picky]
+          end
+        end
+        context 'max_length == -1' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(@sym.size, -1) do |subtoken|
+              result << subtoken
+            end
+            result.should == [:picky]
+          end
+        end
+      end
+      context 'with min_length > sym.size' do
+        it "yields the right elements" do
+          result = []
+          @sym.each_intoken(@sym.size+1) do |subtoken|
+            result << subtoken
+          end
+          result.should == []
+        end
+        context 'max_length == 0' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(@sym.size+1, 0) do |subtoken|
+              result << subtoken
+            end
+            result.should == []
+          end
+        end
+        context 'max_length == 1' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(@sym.size+1, 1) do |subtoken|
+              result << subtoken
+            end
+            result.should == []
+          end
+        end
+        context 'max_length == 2' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(@sym.size+1, 2) do |subtoken|
+              result << subtoken
+            end
+            result.should == []
+          end
+        end
+        context 'max_length == 10' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(@sym.size+1, 10) do |subtoken|
+              result << subtoken
+            end
+            result.should == []
+          end
+        end
+        context 'max_length == -1' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(@sym.size+1, -1) do |subtoken|
+              result << subtoken
+            end
+            result.should == []
+          end
+        end
+      end
+      context 'with min_length < 0' do
+        it "yields the right elements" do
+          result = []
+          @sym.each_intoken(-2) do |subtoken|
+            result << subtoken
+          end
+          result.should == [:picky, :pick, :icky]
+        end
+        context 'max_length == 0' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(-2, 0) do |subtoken|
+              result << subtoken
+            end
+            result.should == []
+          end
+        end
+        context 'max_length == 1' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(-2, 1) do |subtoken|
+              result << subtoken
+            end
+            result.should == []
+          end
+        end
+        context 'max_length == 2' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(-2, 2) do |subtoken|
+              result << subtoken
+            end
+            result.should == []
+          end
+        end
+        context 'max_length == 10' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(-2, 10) do |subtoken|
+              result << subtoken
+            end
+            result.should == [:picky, :pick, :icky]
+          end
+        end
+        context 'max_length == -1' do
+          it 'yields the right elements' do
+            result = []
+            @sym.each_intoken(-2, -1) do |subtoken|
+              result << subtoken
+            end
+            result.should == [:picky, :pick, :icky]
+          end
+        end
+      end
+    end
   end
   
   describe "each_subtoken" do