picky 3.2.0 → 3.3.0

data/lib/picky/wrappers/bundle/delegators.rb

@@ -0,0 +1,69 @@
+module Picky
+
+  module Wrappers
+
+    module Bundle
+
+      module Delegator
+
+        delegate :inverted,
+                 :weights,
+                 :similarity,
+                 :configuration,
+
+                 :backup,
+                 :restore,
+                 :delete,
+
+                 :raise_unless_cache_exists,
+                 :raise_unless_index_exists,
+                 :raise_unless_similarity_exists,
+
+                 :similar,
+
+                 :to => :bundle
+
+      end
+
+      module IndexingDelegator
+
+        delegate :[]=,
+                 :analyze,
+                 :dump,
+                 :empty,
+                 :empty_configuration,
+                 :generate_caches_from_memory,
+                 :generate_caches_from_source,
+                 :generate_partial_from,
+                 :retrieve,
+                 :size,
+                 :to => :bundle
+
+      end
+
+      module IndexedDelegator
+
+        delegate :[],
+                 :clear,
+                 :clear_inverted,
+                 :clear_weights,
+                 :clear_similarity,
+                 :clear_configuration,
+                 :identifier,
+                 :ids,
+                 :load,
+                 :load_inverted,
+                 :load_weights,
+                 :load_similarity,
+                 :load_configuration,
+                 :name,
+                 :weight,
+                 :to => :bundle
+
+      end
+
+    end
+
+  end
+
+end

data/lib/picky/wrappers/bundle/exact_partial.rb

@@ -0,0 +1,38 @@
+# encoding: utf-8
+#
+module Picky
+
+  module Wrappers
+
+    module Bundle
+
+      # This index combines a partial and exact
+      # bundle such that a partial index will not
+      # be dumped or generated.
+      #
+      class ExactPartial
+
+        attr_reader :bundle
+
+        include Delegator
+        include IndexedDelegator
+
+        def initialize bundle
+          @bundle = bundle
+        end
+
+        def clear; end
+        def dump; end
+        def empty_configuration; end
+        def generate_caches_from_memory; end
+        def generate_partial_from arg; end
+        def index; end
+        def load; end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/picky/{indexed/wrappers → wrappers}/bundle/location.rb

@@ -1,6 +1,5 @@
 module Picky
 
-  module Indexed
     module Wrappers
 
       module Bundle
@@ -30,17 +29,20 @@ module Picky
             # Load first the bundle, then extract the config.
             #
             bundle.load
-            # THINK Can I move the to_f to the backend?
-            #
             minimum = bundle[:location_minimum] && bundle[:location_minimum].to_f || raise("Configuration :location_minimum for #{bundle.identifier} missing. Did you run rake index already?")
             @calculation.minimum = minimum
           end
 
+          # Do not generate a partial.
+          #
+          def generate_partial_from unimportant
+            # Nothing.
+          end
+
         end
 
       end
 
-    end
   end
 
 end

data/lib/picky/wrappers/bundle/wrapper.rb

@@ -0,0 +1,29 @@
+module Picky
+
+  module Wrappers
+
+    # Per Bundle wrappers.
+    #
+    module Bundle
+
+      # Base wrapper. Just delegates all methods to the bundle.
+      #
+      class Wrapper
+
+        include Delegator
+        include IndexingDelegator
+        include IndexedDelegator
+
+        attr_reader :bundle
+
+        def initialize bundle
+          @bundle = bundle
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/picky/wrappers/category/exact_first.rb

@@ -0,0 +1,55 @@
+# encoding: utf-8
+#
+module Picky
+
+  module Wrappers
+
+    # This index combines an exact and partial index.
+    # It serves to order the results such that exact hits are found first.
+    #
+    class ExactFirst < Bundle
+
+      delegate :similar,
+               :identifier,
+               :name,
+               :to => :@exact
+      delegate :index,
+               :category,
+               :weight,
+               :generate_partial_from,
+               :generate_caches_from_memory,
+               :generate_derived,
+               :dump,
+               :load,
+               :to => :@partial
+
+      def initialize category
+        @exact   = category.exact
+        @partial = category.partial
+      end
+
+      def self.wrap index_or_category
+        if index_or_category.respond_to? :categories
+          wrap_each_of index_or_category.categories
+          index_or_category
+        else
+          new index_or_category
+        end
+      end
+      def self.wrap_each_of categories
+        categories.categories.collect! { |category| new(category) }
+      end
+
+      def ids text
+        @exact.ids(text) + @partial.ids(text)
+      end
+
+      def weight text
+        [@exact.weight(text) || 0, @partial.weight(text) || 0].max
+      end
+
+    end
+
+  end
+
+end

data/lib/picky/wrappers/category/location.rb

@@ -0,0 +1,33 @@
+module Picky
+  module Wrappers
+    module Category
+
+      module Location
+
+        # THINK Is this the best way to do this?
+        #
+        def self.wrap category, grid, precision = 1
+          wrapped_exact = Wrappers::Bundle::Location.new category.exact, grid: grid, precision: precision
+          new_source    = Wrappers::Sources::Location.new category.source, grid, precision
+
+          category.class_eval do
+            define_method :exact do
+              wrapped_exact
+            end
+            define_method :partial do
+              wrapped_exact
+            end
+            def tokenizer
+              @tokenizer ||= Tokenizer.new
+            end
+            define_method :source do
+              new_source
+            end
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/picky/{sources/wrappers → wrappers/sources}/base.rb

@@ -1,12 +1,12 @@
 module Picky
 
-  module Sources
+  module Wrappers
 
     # Source wrappers can be used to rewrite data before it goes into the index.
     #
     # For example if you want to normalize data.
     #
-    module Wrappers # :nodoc:all
+    module Sources # :nodoc:all
 
       class Base
 
@@ -20,7 +20,11 @@ module Picky
 
         # Default is delegation for all methods
         #
-        delegate :harvest, :connect_backend, :take_snapshot, :key_format, :to => :source
+        delegate :harvest,
+                 :connect_backend,
+                 :take_snapshot,
+                 :key_format,
+                 :to => :source
 
       end
 

data/lib/picky/{sources/wrappers → wrappers/sources}/location.rb

@@ -1,8 +1,8 @@
 module Picky
 
-  module Sources
+  module Wrappers
 
-    module Wrappers
+    module Sources
 
       # Should this actually just be a tokenizer?
       #
@@ -44,7 +44,7 @@ module Picky
 
           # TODO Move to the right place.
           #
-          category.indexing_exact[:location_minimum] = minimum
+          category.exact[:location_minimum] = minimum
         end
 
       end

data/lib/picky.rb

@@ -1,19 +1,12 @@
 module Picky
 
-  # This is only used in the classic project style.
-  #
-  class << self
-    attr_accessor :logger
-  end
-
   # External libraries.
   #
-  require 'rack'
-  require 'rack_fast_escape'
-  require 'text'
-  require 'yajl'
   require 'active_support/core_ext'
-  require 'active_record'
+  require 'text'
+  require 'yajl' # TODO Maybe replace by multi_json.
+  require 'rack' # TODO Remove.
+  require 'rack_fast_escape' # TODO Remove.
 
   # Require the constants.
   #
@@ -32,4 +25,10 @@ module Picky
   #
   require ::File.expand_path '../picky/sinatra', __FILE__
 
+  # This is only used in the classic project style.
+  #
+  class << self
+    attr_accessor :logger
+  end
+
 end

data/spec/aux/picky/cli_spec.rb

@@ -11,7 +11,7 @@ describe Picky::CLI do
   describe '.mapping' do
     it 'returns the right mapping' do
       Picky::CLI.mapping.should == {
-        :generate => [Picky::CLI::Generate, :"{sinatra_client,unicorn_server,empty_unicorn_server}", :app_directory_name],
+        :generate => [Picky::CLI::Generate, :"{client,server,sinatra_client,unicorn_server,all_in_one}", :app_directory_name],
         :help     => [Picky::CLI::Help],
         :live     => [Picky::CLI::Live, "host:port/path (default: localhost:8080/admin)", "port (default: 4568)"],
         :search   => [Picky::CLI::Search, :url_or_path, 'amount of ids (default 20)'],
@@ -31,7 +31,7 @@ describe Picky::CLI do
       it 'calls help correctly' do
         Kernel.should_receive(:puts).once.with <<-HELP
 Possible commands:
-  picky generate {sinatra_client,unicorn_server,empty_unicorn_server} app_directory_name
+  picky generate {client,server,sinatra_client,unicorn_server,all_in_one} app_directory_name
   picky help 
   picky live [host:port/path (default: localhost:8080/admin)] [port (default: 4568)]
   picky search url_or_path [amount of ids (default 20)]
@@ -51,7 +51,7 @@ HELP
         cli.executor_class_for.should == [Picky::CLI::Help]
       end
       it 'returns Generator for generate' do
-        cli.executor_class_for(:generate).should == [Picky::CLI::Generate, :'{sinatra_client,unicorn_server,empty_unicorn_server}', :"app_directory_name"]
+        cli.executor_class_for(:generate).should == [Picky::CLI::Generate, :'{client,server,sinatra_client,unicorn_server,all_in_one}', :"app_directory_name"]
       end
       it 'returns Help for help' do
         cli.executor_class_for(:help).should == [Picky::CLI::Help]
@@ -72,11 +72,11 @@ HELP
   end
   
   describe Picky::CLI::Live do
-    let(:executor) { described_class.new }
+    let(:executor) { Picky::CLI::Live.new }
   end
   
   describe Picky::CLI::Base do
-    let(:executor) { described_class.new }
+    let(:executor) { Picky::CLI::Base.new }
     describe 'usage' do
       it 'calls puts with an usage' do
         executor.should_receive(:puts).once.with "Usage:\n  picky some_name param1 [param2]"

data/spec/lib/backends/backend_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Picky::Backends::Backend do
+
+  context 'without options' do
+    let(:backend) { described_class.new }
+
+    describe 'extract_lambda_or' do
+      it 'returns a given non-lambda' do
+        backend.extract_lambda_or(:thing).should == :thing
+      end
+      it 'calls a given lambda with the given args' do
+        lam = ->() do
+          :lam
+        end
+        
+        backend.extract_lambda_or(lam).should == :lam
+      end
+      it 'calls a given lambda with the given args' do
+        lam = ->(arg1) do
+          arg1.should == 1
+          :lam
+        end
+        
+        backend.extract_lambda_or(lam, 1).should == :lam
+      end
+      it 'calls a given lambda with the given args' do
+        lam = ->(arg1, arg2) do
+          arg1.should == 1
+          arg2.should == 2
+          :lam
+        end
+        
+        backend.extract_lambda_or(lam, 1, 2).should == :lam
+      end
+    end
+  end
+
+end

data/spec/lib/backends/file/basic_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe Picky::Backends::File::Basic do
+  
+  context 'without options' do
+    let(:basic) { described_class.new 'some/cache/path/to/file' }
+
+    describe 'empty' do
+      it 'returns the container that is used for indexing' do
+        basic.empty.should == {}
+      end
+    end
+    
+    describe 'initial' do
+      it 'returns the container that is used for indexing' do
+        basic.initial.should == nil
+      end
+    end
+
+    describe 'backup_file_path_of' do
+      it 'returns a backup path relative to the path' do
+        basic.backup_file_path_of('some/path/to/some.memory.index').should == 'some/path/to/backup/some.memory.index'
+      end
+    end
+  
+    describe 'backup_directory' do
+      it "returns the cache path's backup path" do
+        basic.backup_directory('some/cache/path/to/file').should == 'some/cache/path/to/backup'
+      end
+    end
+  
+    describe 'to_s' do
+      it 'returns the cache path with the default file extension' do
+        basic.to_s.should == 'Picky::Backends::File::Basic(some/cache/path/to/file.file.index,some/cache/path/to/file.file_mapping.index.memory.json)'
+      end
+    end
+  end
+  
+  context 'with options' do
+    let(:basic) do
+      described_class.new 'some/cache/path/to/file',
+                          empty: [],
+                          initial: []
+    end
+
+    describe 'empty' do
+      it 'returns the container that is used for indexing' do
+        basic.empty.should == []
+      end
+    end
+    
+    describe 'initial' do
+      it 'returns the container that is used for indexing' do
+        basic.initial.should == []
+      end
+    end
+  end
+  
+end

data/spec/lib/backends/file_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+describe Picky::Backends::File do
+
+  context 'with options' do
+    before(:each) do
+      @backend = described_class.new inverted:      Picky::Backends::File::Basic.new(:unimportant),
+                                     weights:       Picky::Backends::File::Basic.new(:unimportant),
+                                     similarity:    Picky::Backends::File::Basic.new(:unimportant),
+                                     configuration: Picky::Backends::File::Basic.new(:unimportant)
+
+      @backend.stub! :timed_exclaim
+    end
+  
+    describe 'create_...' do
+      [
+        [:inverted,      Picky::Backends::File::Basic],
+        [:weights,       Picky::Backends::File::Basic],
+        [:similarity,    Picky::Backends::File::Basic],
+        [:configuration, Picky::Backends::File::Basic]
+      ].each do |type, kind|
+        it "creates and returns a(n) #{type} index" do
+          @backend.send(:"create_#{type}",
+                        stub(type, :index_path => "spec/test_directory/index/test/some_index/some_category_some_bundle_#{type}")
+          ).should be_kind_of(kind)
+        end
+      end
+    end
+  end
+
+  context 'without options' do
+    before(:each) do
+      @backend = described_class.new
+
+      @backend.stub! :timed_exclaim
+    end
+  
+    describe 'create_...' do
+      [
+        [:inverted,      Picky::Backends::File::JSON],
+        [:weights,       Picky::Backends::File::JSON],
+        [:similarity,    Picky::Backends::File::JSON],
+        [:configuration, Picky::Backends::File::JSON]
+      ].each do |type, kind|
+        it "creates and returns a(n) #{type} index" do
+          @backend.send(:"create_#{type}",
+                        stub(type, :index_path => "spec/test_directory/index/test/some_index/some_category_some_bundle_#{type}")
+          ).should be_kind_of(kind)
+        end
+      end
+    end
+  
+    describe "ids" do
+      before(:each) do
+        @combination1 = stub :combination1
+        @combination2 = stub :combination2
+        @combination3 = stub :combination3
+        @combinations = [@combination1, @combination2, @combination3]
+      end
+      it "should intersect correctly" do
+        @combination1.should_receive(:ids).once.with.and_return (1..100_000).to_a
+        @combination2.should_receive(:ids).once.with.and_return (1..100).to_a
+        @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+        @backend.ids(@combinations, :any, :thing).should == (1..10).to_a
+      end
+      it "should intersect symbol_keys correctly" do
+        @combination1.should_receive(:ids).once.with.and_return (:'00001'..:'10000').to_a
+        @combination2.should_receive(:ids).once.with.and_return (:'00001'..:'00100').to_a
+        @combination3.should_receive(:ids).once.with.and_return (:'00001'..:'00010').to_a
+
+        @backend.ids(@combinations, :any, :thing).should == (:'00001'..:'0010').to_a
+      end
+      it "should intersect correctly when intermediate intersect result is empty" do
+        @combination1.should_receive(:ids).once.with.and_return (1..100_000).to_a
+        @combination2.should_receive(:ids).once.with.and_return (11..100).to_a
+        @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+        @backend.ids(@combinations, :any, :thing).should == []
+      end
+      it "should be fast" do
+        @combination1.should_receive(:ids).once.with.and_return (1..100_000).to_a
+        @combination2.should_receive(:ids).once.with.and_return (1..100).to_a
+        @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+        performance_of { @backend.ids(@combinations, :any, :thing) }.should < 0.004
+      end
+      it "should be fast" do
+        @combination1.should_receive(:ids).once.with.and_return (1..1000).to_a
+        @combination2.should_receive(:ids).once.with.and_return (1..100).to_a
+        @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+        performance_of { @backend.ids(@combinations, :any, :thing) }.should < 0.00015
+      end
+      it "should be fast" do
+        @combination1.should_receive(:ids).once.with.and_return (1..1000).to_a
+        @combination2.should_receive(:ids).once.with.and_return (901..1000).to_a
+        @combination3.should_receive(:ids).once.with.and_return (1..10).to_a
+
+        performance_of { @backend.ids(@combinations, :any, :thing) }.should < 0.0001
+      end
+    end
+  end
+
+end

data/spec/lib/backends/memory/basic_spec.rb

@@ -2,29 +2,57 @@ require 'spec_helper'
 
 describe Picky::Backends::Memory::Basic do
   
-  let(:basic) { described_class.new 'some/cache/path/to/file' }
+  context 'without options' do
+    let(:basic) { described_class.new 'some/cache/path/to/file' }
 
-  describe 'empty' do
-    it 'returns the container that is used for indexing' do
-      basic.empty.should == {}
+    describe 'empty' do
+      it 'returns the container that is used for indexing' do
+        basic.empty.should == {}
+      end
+    end
+    
+    describe 'initial' do
+      it 'returns the container that is used for indexing' do
+        basic.initial.should == {}
+      end
     end
-  end
 
-  describe 'backup_file_path_of' do
-    it 'returns a backup path relative to the path' do
-      basic.backup_file_path_of('some/path/to/some.memory.index').should == 'some/path/to/backup/some.memory.index'
+    describe 'backup_file_path_of' do
+      it 'returns a backup path relative to the path' do
+        basic.backup_file_path_of('some/path/to/some.memory.index').should == 'some/path/to/backup/some.memory.index'
+      end
+    end
+  
+    describe 'backup_directory' do
+      it "returns the cache path's backup path" do
+        basic.backup_directory('some/cache/path/to/file').should == 'some/cache/path/to/backup'
+      end
     end
-  end
   
-  describe 'backup_directory' do
-    it "returns the cache path's backup path" do
-      basic.backup_directory('some/cache/path/to/file').should == 'some/cache/path/to/backup'
+    describe 'to_s' do
+      it 'returns the cache path with the default file extension' do
+        basic.to_s.should == 'Picky::Backends::Memory::Basic(some/cache/path/to/file.memory.index)'
+      end
     end
   end
   
-  describe 'to_s' do
-    it 'returns the cache path with the default file extension' do
-      basic.to_s.should == 'Picky::Backends::Memory::Basic(some/cache/path/to/file.memory.index)'
+  context 'with options' do
+    let(:basic) do
+      described_class.new 'some/cache/path/to/file',
+                          empty: [],
+                          initial: []
+    end
+
+    describe 'empty' do
+      it 'returns the container that is used for indexing' do
+        basic.empty.should == []
+      end
+    end
+    
+    describe 'initial' do
+      it 'returns the container that is used for indexing' do
+        basic.initial.should == []
+      end
     end
   end