picky 0.0.0 → 0.0.2

data/spec/lib/index/bundle_partial_generation_speed_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe Index::Bundle do
+
+  before(:each) do
+    @category         = stub :category, :name => :some_category
+    @type             = stub :type, :name => :some_type
+    @partial_strategy = Cacher::Partial::Subtoken.new :down_to => 1
+    @full             = Index::Bundle.new :some_name, @category, @type, @partial_strategy, nil, nil
+  end
+
+  def generate_random_keys amount
+    alphabet = ('a'..'z').to_a
+    (1..amount).to_a.collect! do |n|
+      Array.new(20).collect! { alphabet[rand(26)] }.join.to_sym
+    end
+  end
+  def generate_random_ids amount
+    (1..amount).to_a.collect! do |_|
+      Array.new(rand(100)+5).collect! do |_|
+        rand(5_000_000)
+      end
+    end
+  end
+
+  describe 'speed' do
+    context 'medium arrays' do
+      before(:each) do
+        random_keys  = generate_random_keys 500
+        random_ids   = generate_random_ids  500
+        @full.index = Hash[random_keys.zip(random_ids)]
+
+        GC.disable
+      end
+      after(:each) do
+        GC.enable
+        GC.start
+      end
+      it 'should be fast' do
+        Benchmark.realtime do
+          @full.generate_partial
+        end.should <= 0.2
+      end
+    end
+  end
+
+end

data/spec/lib/index/bundle_spec.rb

@@ -0,0 +1,260 @@
+require 'spec_helper'
+
+describe Index::Bundle do
+
+  before(:each) do
+    @category    = stub :category, :name => :some_category
+    @type        = stub :type, :name => :some_type
+    @partial     = stub :partial
+    @weights     = stub :weights
+    @similarity  = stub :similarity
+    @index_class = Index::Bundle
+    @index       = @index_class.new :some_name, @category, @type, @partial, @weights, @similarity
+  end
+
+  describe 'identifier' do
+    it 'should return a specific identifier' do
+      @index.identifier.should == 'some_name:some_type:some_category'
+    end
+  end
+
+  describe 'create_directory' do
+    it 'should use makedirs to create the necessary directory structure' do
+      FileUtils.should_receive(:mkdir_p).once.with 'some/search/root/index/test/some_type'
+
+      @index.create_directory
+    end
+  end
+
+  describe 'cache_directory' do
+    it 'should be correct' do
+      @index.cache_directory.should == 'some/search/root/index/test/some_type'
+    end
+  end
+
+  describe 'initialize_index_for' do
+    context 'token not yet assigned' do
+      before(:each) do
+        @index.stub! :index => {}
+      end
+      it 'should assign it an empty array' do
+        @index.initialize_index_for :some_token
+
+        @index.index[:some_token].should == []
+      end
+    end
+    context 'token already assigned' do
+      before(:each) do
+        @index.stub! :index => { :some_token => :already_assigned }
+      end
+      it 'should not assign it anymore' do
+        @index.initialize_index_for :some_token
+
+        @index.index[:some_token].should == :already_assigned
+      end
+    end
+  end
+  
+  # FIXME
+  #
+  # describe 'retrieve' do
+  #   it 'should call the other methods correctly' do
+  #     results = stub :results
+  #     @index.stub! :execute_query => results
+  #     @index.should_receive(:extract).once.with results
+  #     
+  #     @index.retrieve
+  #   end
+  # end
+
+  describe 'load_from_index_file' do
+    it 'should call two methods in order' do
+      @index.should_receive(:clear).once.ordered
+      @index.should_receive(:retrieve).once.ordered
+
+      @index.load_from_index_file
+    end
+  end
+
+  describe 'generate_derived' do
+    it 'should call two methods in order' do
+      @index.should_receive(:generate_weights).once.ordered
+      @index.should_receive(:generate_similarity).once.ordered
+
+      @index.generate_derived
+    end
+  end
+
+  describe 'generate_caches_from_memory' do
+    it 'should call two methods in order' do
+      @index.should_receive(:cache_from_memory_generation_message).once.ordered
+      @index.should_receive(:generate_derived).once.ordered
+
+      @index.generate_caches_from_memory
+    end
+  end
+
+  describe 'generate_caches_from_db' do
+    it 'should call two methods in order' do
+      @index.should_receive(:cache_from_db_generation_message).once.ordered
+      @index.should_receive(:load_from_index_file).once.ordered
+      @index.should_receive(:generate_caches_from_memory).once.ordered
+
+      @index.generate_caches_from_db
+    end
+  end
+
+  describe 'ids' do
+    before(:each) do
+      @index.instance_variable_set :@index, { :existing => :some_ids }
+    end
+    it 'should return an empty array if not found' do
+      @index.ids(:non_existing).should == []
+    end
+    it 'should return the ids if found' do
+      @index.ids(:existing).should == :some_ids
+    end
+  end
+
+  describe 'weight' do
+    before(:each) do
+      @index.instance_variable_set :@weights, { :existing => :specific }
+    end
+    it 'should return nil' do
+      @index.weight(:non_existing).should == nil
+    end
+    it 'should return the weight for the text' do
+      @index.weight(:existing).should == :specific
+    end
+  end
+
+  describe 'raise_unless_cache_exists' do
+    before(:each) do
+      @index.stub! :cache_small? => false
+    end
+    context 'weights cache missing' do
+      before(:each) do
+        @index.stub! :cache_ok? => true
+        @index.stub! :weights_cache_path => 'weights_cache_path'
+        @index.should_receive(:cache_ok?).any_number_of_times.with('weights_cache_path').and_return false
+      end
+      it 'should raise' do
+        lambda do
+          @index.raise_unless_cache_exists
+        end.should raise_error("weights cache for some_name:some_type:some_category missing.")
+      end
+    end
+    context 'similarity cache missing' do
+      before(:each) do
+        @index.stub! :cache_ok? => true
+        @index.stub! :similarity_cache_path => 'similarity_cache_path'
+        @index.should_receive(:cache_ok?).any_number_of_times.with('similarity_cache_path').and_return false
+      end
+      it 'should raise' do
+        lambda do
+          @index.raise_unless_cache_exists
+        end.should raise_error("similarity cache for some_name:some_type:some_category missing.")
+      end
+    end
+    context 'index cache missing' do
+      before(:each) do
+        @index.stub! :cache_ok? => true
+        @index.stub! :index_cache_path => 'index_cache_path'
+        @index.should_receive(:cache_ok?).any_number_of_times.with('index_cache_path').and_return false
+      end
+      it 'should raise' do
+        lambda do
+          @index.raise_unless_cache_exists
+        end.should raise_error("index cache for some_name:some_type:some_category missing.")
+      end
+    end
+    context 'all ok' do
+      before(:each) do
+        @index.stub! :cache_ok? => true
+      end
+      it 'should not raise' do
+        lambda { @index.raise_unless_cache_exists }.should_not raise_error
+      end
+    end
+  end
+
+  describe 'delete_all' do
+    it 'should call delete with all paths' do
+      @index.should_receive(:delete).once.with @index.index_cache_path
+      @index.should_receive(:delete).once.with @index.similarity_cache_path
+      @index.should_receive(:delete).once.with @index.weights_cache_path
+
+      @index.delete_all
+    end
+  end
+
+  describe 'load' do
+    it 'should trigger loads' do
+      @index.should_receive(:load_index).once.with
+      @index.should_receive(:load_similarity).once.with
+      @index.should_receive(:load_weights).once.with
+
+      @index.load
+    end
+  end
+
+  describe 'dump' do
+    it 'should trigger dumps' do
+      @index.should_receive(:dump_index).once.with
+      @index.should_receive(:dump_similarity).once.with
+      @index.should_receive(:dump_weights).once.with
+
+      @index.dump
+    end
+  end
+
+  describe 'weights_cache_path' do
+    it 'should return the correct file name' do
+      @index.weights_cache_path.should == 'some/search/root/index/test/some_type/some_name_some_category_weights.dump'
+    end
+  end
+  describe 'similarity_cache_path' do
+    it 'should return the correct file name' do
+      @index.similarity_cache_path.should == 'some/search/root/index/test/some_type/some_name_some_category_similarity.dump'
+    end
+  end
+  describe 'index_cache_path' do
+    it 'should return the correct file name' do
+      @index.index_cache_path.should == 'some/search/root/index/test/some_type/some_name_some_category_index.dump'
+    end
+  end
+
+  describe 'initialization' do
+    before(:each) do
+      @index = @index_class.new :some_name, :some_category, :some_type, :partial, :weights, :similarity
+    end
+    it 'should initialize the index correctly' do
+      @index.index.should == {}
+    end
+    it 'should initialize the weights index correctly' do
+      @index.weights.should == {}
+    end
+    it 'should initialize the similarity index correctly' do
+      @index.similarity.should == {}
+    end
+    it 'should initialize the name correctly' do
+      @index.name.should == :some_name
+    end
+    it 'should initialize the name correctly' do
+      @index.category.should == :some_category
+    end
+    it 'should initialize the name correctly' do
+      @index.type.should == :some_type
+    end
+    it 'should initialize the partial strategy correctly' do
+      @index.partial_strategy.should == :partial
+    end
+    it 'should initialize the weights strategy correctly' do
+      @index.weights_strategy.should == :weights
+    end
+    it 'should initialize the similarity strategy correctly' do
+      @index.similarity_strategy.should == :similarity
+    end
+  end
+
+end

data/spec/lib/index/category_spec.rb

@@ -0,0 +1,203 @@
+require 'spec_helper'
+
+describe Index::Category do
+
+  before(:each) do
+    @field      = stub :field, :name => :some_name
+    @type       = stub :type, :name => :some_type
+    @partial    = stub :partial
+    @weights    = stub :weights
+    @similarity = stub :similarity
+    @category   = Index::Category.new @field, @type, :partial => @partial, :weights => @weights, :similarity => @similarity
+
+    @full    = stub :full, :dump => nil
+    @category.stub! :full => @full
+
+    @partial = stub :partial, :dump => nil
+    @category.stub! :partial => @partial
+  end
+
+  describe 'dump_caches' do
+    it 'should dump the full index' do
+      @full.should_receive(:dump).once.with
+
+      @category.dump_caches
+    end
+    it 'should dump the partial index' do
+      @partial.should_receive(:dump).once.with
+
+      @category.dump_caches
+    end
+  end
+
+  describe 'generate_derived_partial' do
+    it 'should delegate to partial' do
+      @partial.should_receive(:generate_derived).once.with
+
+      @category.generate_derived_partial
+    end
+  end
+
+  describe 'generate_derived_full' do
+    it 'should delegate to full' do
+      @full.should_receive(:generate_derived).once.with
+
+      @category.generate_derived_full
+    end
+  end
+
+  describe 'generate_indexes_from_full_index' do
+    it 'should call three method in order' do
+      @category.should_receive(:generate_derived_full).once.with().ordered
+      @category.should_receive(:generate_partial).once.with().ordered
+      @category.should_receive(:generate_derived_partial).once.with().ordered
+
+      @category.generate_indexes_from_full_index
+    end
+  end
+
+  describe 'weight' do
+    before(:each) do
+      @token = stub :token, :text => :some_text
+    end
+    context 'partial bundle' do
+      before(:each) do
+        @category.stub! :bundle_for => @partial
+      end
+      it 'should receive weight with the token text' do
+        @partial.should_receive(:weight).once.with :some_text
+
+        @category.weight @token
+      end
+    end
+    context 'full bundle' do
+      before(:each) do
+        @category.stub! :bundle_for => @full
+      end
+      it 'should receive weight with the token text' do
+        @full.should_receive(:weight).once.with :some_text
+
+        @category.weight @token
+      end
+    end
+  end
+
+  describe 'ids' do
+    before(:each) do
+      @token = stub :token, :text => :some_text
+    end
+    context 'partial bundle' do
+      before(:each) do
+        @category.stub! :bundle_for => @partial
+      end
+      it 'should receive ids with the token text' do
+        @partial.should_receive(:ids).once.with :some_text
+
+        @category.ids @token
+      end
+    end
+    context 'full bundle' do
+      before(:each) do
+        @category.stub! :bundle_for => @full
+      end
+      it 'should receive ids with the token text' do
+        @full.should_receive(:ids).once.with :some_text
+
+        @category.ids @token
+      end
+    end
+  end
+
+  describe 'combination_for' do
+    context 'no weight for token' do
+      before(:each) do
+        @category.stub! :weight => nil
+      end
+      it 'should return nil' do
+        @category.combination_for(:anything).should == nil
+      end
+    end
+    context 'weight for token' do
+      before(:each) do
+        @token = stub :token, :text => :some_text
+        @category.stub! :weight => :some_weight, :bundle_for => :bundle
+      end
+      it 'should return a new combination' do
+        @category.combination_for(@token).should be_kind_of(::Query::Combination)
+      end
+      it 'should create the combination correctly' do
+        ::Query::Combination.should_receive(:new).once.with @token, @category
+
+        @category.combination_for @token
+      end
+    end
+  end
+
+  describe 'bundle_for' do
+    it 'should return the right bundle' do
+      token = stub :token, :partial? => false
+
+      @category.bundle_for(token).should == @full
+    end
+    it 'should return the right bundle' do
+      token = stub :token, :partial? => true
+
+      @category.bundle_for(token).should == @partial
+    end
+  end
+
+  describe 'generate_caches_from_memory' do
+    it 'should delegate to partial' do
+      @partial.should_receive(:generate_caches_from_memory).once.with
+
+      @category.generate_caches_from_memory
+    end
+  end
+
+  describe 'generate_partial' do
+    it 'should return whatever the partial generation returns' do
+      @full.stub! :index
+      @partial.stub! :generate_partial_from => :generation_returns
+
+      @category.generate_partial
+    end
+    it 'should use the full index to generate the partial index' do
+      full_index = stub :full_index
+      @full.stub! :index => full_index
+      @partial.should_receive(:generate_partial_from).once.with(full_index)
+
+      @category.generate_partial
+    end
+  end
+
+  describe 'generate_caches_from_db' do
+    it 'should delegate to full' do
+      @full.should_receive(:generate_caches_from_db).once.with
+
+      @category.generate_caches_from_db
+    end
+  end
+
+  describe 'generate_caches' do
+    before(:each) do
+      @category.stub! :exclaim
+    end
+    it 'should call three method in order' do
+      @category.should_receive(:generate_caches_from_db).once.with().ordered
+      @category.should_receive(:generate_partial).once.with().ordered
+      @category.should_receive(:generate_caches_from_memory).once.with().ordered
+      
+      @category.generate_caches
+    end
+  end
+  
+  describe 'load_from_cache' do
+    it 'should call two methods' do
+      @full.should_receive(:load).once
+      @partial.should_receive(:load).once
+      
+      @category.load_from_cache
+    end
+  end
+
+end

data/spec/lib/indexers/base_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe Indexers::Base do
+
+  before(:each) do
+    @type  = stub :type,
+                  :name => :some_type,
+                  :snapshot_table_name => :some_prepared_table_name
+    @field = stub :field,
+                  :name => :some_field_name,
+                  :search_index_file_name => :some_search_index_name,
+                  :indexed_name => :some_indexed_field_name
+    @indexer = Indexers::Base.new @type, @field
+    @indexer.stub! :indexing_message
+  end
+  
+  describe "tokenizer" do
+    it "should delegate to field" do
+      @field.should_receive(:tokenizer).once.with
+      
+      @indexer.tokenizer
+    end
+  end
+  
+  describe 'search_index_file_name' do
+    it 'should return a specific name' do
+      @indexer.search_index_file_name.should == :some_search_index_name
+    end
+  end
+  
+  describe "index" do
+    it "should execute! the indexer" do
+      @indexer.should_receive(:process).once.with
+      
+      @indexer.index
+    end
+  end
+  
+  describe "source" do
+    before(:each) do
+      @source = stub :source
+    end
+    context "field has one" do
+      before(:each) do
+        @field.stub! :source => @source
+      end
+      it "should return that one" do
+        @indexer.source.should == @source
+      end
+    end
+    context "field doesn't have one" do
+      before(:each) do
+        @field.stub! :source => nil
+      end
+      it "should call raise_no_source" do
+        @indexer.should_receive(:raise_no_source).once.with
+        
+        @indexer.source
+      end
+    end
+  end
+  
+  describe "raise_no_source" do
+    it "should raise" do
+      lambda { @indexer.raise_no_source }.should raise_error(Indexers::NoSourceSpecifiedException)
+    end
+  end
+  
+  describe "chunked" do
+    
+  end
+  
+end

data/spec/lib/indexers/field_spec.rb

@@ -0,0 +1,20 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Indexers::Field do
+
+  before(:each) do
+    @type  = stub :type, :name => :some_type, :snapshot_table_name => :some_prepared_table_name
+    @field = stub :field, :indexed_name => :some_indexed_field_name, :name => :some_field_name, :search_index_file_name => :some_index_table
+    @strategy = Indexers::Field.new @type, @field
+    @strategy.stub! :indexing_message
+  end
+
+  describe "chunksize" do
+    it "should be a specific size" do
+      @strategy.chunksize.should == 25_000
+    end
+  end
+
+end

data/spec/lib/loader_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+describe Loader do
+
+  before(:each) do
+    @loader_path = File.absolute_path("#{File.dirname(__FILE__)}/../../lib/picky/loader.rb")
+    Configuration.stub! :apply
+    Indexes.stub! :setup
+  end
+
+  describe 'load_self' do
+    before(:each) do
+      Loader.stub! :load
+      Loader.stub! :exclaim
+    end
+    after(:each) do
+      Loader.load_self
+    end
+    it 'should load __SELF__' do
+      Loader.should_receive(:load).once.with @loader_path
+    end
+  end
+
+  describe 'reload' do
+    before(:each) do
+      load @loader_path
+      Loader.stub! :exclaim
+      Loader.stub! :load_framework
+      Loader.stub! :load_application
+      Dir.stub! :chdir
+    end
+    after(:each) do
+      Loader.reload
+    end
+    it 'should call the right methods in order' do
+      Loader.should_receive(:load_self).ordered
+      Loader.should_receive(:load_framework).ordered
+      Loader.should_receive(:load_application).ordered
+    end
+    it 'should load itself only once' do
+      Loader.should_receive(:load_self).once
+    end
+    # it 'should load the app only once' do
+    #   Loader.should_receive(:load_framework).once
+    # end
+  end
+
+end

data/spec/lib/loggers/search_spec.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Loggers::Search do
+  
+  before(:each) do
+    @destination = stub :destination
+    @logger      = Loggers::Search.new @destination
+  end
+  describe "log" do
+    it "should delegate to info" do
+      @destination.should_receive(:info).once.with 'test'
+      
+      @logger.log 'test'
+    end
+  end
+  
+end

data/spec/lib/performant/array_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe 'performant array' do
+
+  # describe "brute_force_intersect" do
+  #   it "should intersect correctly" do
+  #     arys = [[3,4], [1,2,3,4], [3,4,5,8,9]]
+  #
+  #     Performant::Array.brute_force_intersect(arys.sort_by(&:size)).should == [3,4]
+  #   end
+  # end
+
+end