picky 3.6.7 → 3.6.8

data/spec/lib/backends/redis/directly_manipulable_spec.rb

@@ -0,0 +1,91 @@
+require 'spec_helper'
+
+describe Picky::Backends::Redis::DirectlyManipulable do
+
+  let(:client) { stub :client }
+  let(:backend) { stub :backend, client: client, namespace: 'some:namespace' }
+  let(:list) do
+    list = [1,2]
+    described_class.make backend, list, 'some:key'
+    list
+  end
+
+  context 'stubbed backend' do
+    before(:each) do
+      backend.stub! :[]
+    end
+    it 'calls the right client method' do
+      num = described_class.class_variable_get(:@@append_index)
+
+      client.should_receive(:zadd).once.with "some:namespace:some:key", num+1, 3
+
+      list << 3
+    end
+    it 'calls the right client method' do
+      num = described_class.class_variable_get(:@@unshift_index)
+
+      client.should_receive(:zadd).once.with "some:namespace:some:key", num-1, 3
+
+      list.unshift 3
+    end
+    it 'calls the right client method' do
+      client.should_receive(:zrem).once.with "some:namespace:some:key", 1
+
+      list.delete 1
+    end
+    it 'calls the right client method' do
+      client.should_receive(:zrem).never
+
+      list.delete 5
+    end
+  end
+
+  context 'stubbed client' do
+    before(:each) do
+      client.stub! :zadd
+      client.stub! :zrem
+    end
+    it 'calls [] at the end of the method' do
+      backend.should_receive(:[]).once.with 'some:key'
+
+      list << 3
+    end
+    it 'calls [] at the end of the method' do
+      backend.should_receive(:[]).once.with 'some:key'
+
+      list.unshift 3
+    end
+    it 'returns the result' do
+      list.delete(1).should == 1
+    end
+  end
+
+  context 'stubbed client/backend' do
+    before(:each) do
+      backend.stub! :[]
+      client.stub! :zadd
+      client.stub! :zrem
+    end
+    it 'behaves like an ordinary Array' do
+      list << 3
+
+      list.should == [1,2,3]
+    end
+    it 'behaves like an ordinary Array' do
+      list.unshift 3
+
+      list.should == [3,1,2]
+    end
+    it 'behaves like an ordinary Array' do
+      list.delete 1
+
+      list.should == [2]
+    end
+    it 'behaves like an ordinary Array' do
+      list.delete 5
+
+      list.should == [1,2]
+    end
+  end
+
+end

data/spec/lib/backends/redis/float_spec.rb

@@ -1,38 +1,38 @@
 require 'spec_helper'
 
 describe Picky::Backends::Redis::Float do
-  
+
   let(:client) { stub :client }
-  let(:backend) { described_class.new client, :some_namespace }
-    
+  let(:backend) { described_class.new client, 'some_namespace' }
+
   describe 'dump' do
     it 'dumps correctly' do
-      client.should_receive(:del).once.ordered.with  :some_namespace
-      client.should_receive(:hset).once.ordered.with :some_namespace, :a, 1
-      client.should_receive(:hset).once.ordered.with :some_namespace, :b, 2
-      client.should_receive(:hset).once.ordered.with :some_namespace, :c, 3
-      
-      backend.dump a: 1, b: 2, c: 3
+      client.should_receive(:del).once.ordered.with  'some_namespace'
+      client.should_receive(:hset).once.ordered.with 'some_namespace', 'a', 1
+      client.should_receive(:hset).once.ordered.with 'some_namespace', 'b', 2
+      client.should_receive(:hset).once.ordered.with 'some_namespace', 'c', 3
+
+      backend.dump 'a' => 1, 'b' => 2, 'c' => 3
     end
   end
-  
+
   describe 'member' do
     it 'delegates to the backend' do
-      client.should_receive(:hget).once.with :some_namespace, :some_symbol
-      
-      backend[:some_symbol]
+      client.should_receive(:hget).once.with 'some_namespace', 'some'
+
+      backend['some']
     end
     it 'returns whatever it gets from the backend' do
       client.should_receive(:hget).any_number_of_times.and_return '1.23'
-      
-      backend[:anything].should == 1.23
+
+      backend['anything'].should == 1.23
     end
   end
-  
+
   describe 'to_s' do
     it 'returns the cache path with the default file extension' do
       backend.to_s.should == 'Picky::Backends::Redis::Float(some_namespace:*)'
     end
   end
-  
+
 end

data/spec/lib/backends/redis/list_spec.rb

@@ -1,27 +1,27 @@
 require 'spec_helper'
 
 describe Picky::Backends::Redis::List do
-  
+
   let(:client) { stub :client }
   let(:index) { described_class.new client, :some_namespace }
-  
+
   describe '[]' do
     it 'returns whatever comes back from the backend' do
-      client.stub! :zrange => :some_lrange_result
-      
-      index[:anything].should == :some_lrange_result
+      client.stub! :zrange => [:some_lrange_result]
+
+      index[:anything].should == [:some_lrange_result]
     end
     it 'calls the right method on the backend' do
-      client.should_receive(:zrange).once.with "some_namespace:some_sym", 0, -1
-      
+      client.should_receive(:zrange).once.with "some_namespace:some_sym", :"0", :"-1"
+
       index[:some_sym]
     end
   end
-  
+
   describe 'to_s' do
     it 'returns the cache path with the default file extension' do
       index.to_s.should == 'Picky::Backends::Redis::List(some_namespace:*)'
     end
   end
-  
+
 end

data/spec/lib/backends/sqlite/array_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+require 'sqlite3'
+
+describe Picky::Backends::SQLite::Array do
+
+  context 'hash-based indexes' do
+    let(:db) { described_class.new 'some/cache/path/to/file' }
+
+    describe 'dump' do
+      it 'delegates to the given hash' do
+        hash = stub :hash
+
+        db.should_receive(:dump_sqlite).once.with hash
+
+        db.dump hash
+      end
+    end
+
+    describe 'dump_sqlite' do
+      let(:client) { stub :client }
+      before(:each) do
+        db.stub! :db => client
+      end
+      it 'initializes the client' do
+        client.stub! :execute
+
+        db.should_receive(:lazily_initialize_client).once.with
+
+        db.dump_sqlite Hash.new
+      end
+      it 'executes something' do
+        db.stub! :lazily_initialize_client
+
+        client.should_receive(:execute).at_least(1).times
+
+        db.dump_sqlite Hash.new
+      end
+      it 'inserts keys and values' do
+        db.stub! :lazily_initialize_client
+        client.stub! :execute # We only want to test the insert statements.
+
+        client.should_receive(:execute).once.with 'insert into key_value values (?,?)', 'a', '[1,2,3]'
+        client.should_receive(:execute).once.with 'insert into key_value values (?,?)', 'b', '[4,5,6]'
+
+        db.dump_sqlite :a => [1,2,3], :b => [4,5,6]
+      end
+    end
+
+    describe 'load' do
+      it 'returns a copy of itself' do
+        db.load.should == db
+      end
+    end
+
+    describe 'empty' do
+      it 'returns the container that is used for indexing' do
+        db.empty.should == {}
+      end
+    end
+
+    describe 'initial' do
+      it 'is correct' do
+        db.initial.should == {}
+      end
+    end
+
+    describe 'to_s' do
+      it 'returns the cache path with the default file extension' do
+        db.to_s.should == 'Picky::Backends::SQLite::Array(some/cache/path/to/file.sqlite3)'
+      end
+    end
+  end
+
+  context 'hash-based indexes' do
+    let(:db) { described_class.new 'some/cache/path/to/file', self_indexed: true }
+
+    describe 'dump' do
+      it 'delegates to the given hash' do
+        hash = stub :hash
+
+        db.should_receive(:dump_sqlite).never
+
+        db.dump hash
+      end
+    end
+
+    describe 'dump_sqlite' do
+      let(:client) { stub :client }
+      before(:each) do
+        db.stub! :db => client
+      end
+      it 'initializes the client' do
+        client.stub! :execute
+
+        db.should_receive(:lazily_initialize_client).once.with
+
+        db.dump_sqlite Hash.new
+      end
+      it 'executes something' do
+        db.stub! :lazily_initialize_client
+
+        client.should_receive(:execute).at_least(1).times
+
+        db.dump_sqlite Hash.new
+      end
+      it 'inserts keys and values' do
+        db.stub! :lazily_initialize_client
+        client.stub! :execute # We only want to test the insert statements.
+
+        client.should_receive(:execute).once.with 'insert into key_value values (?,?)', 'a', '[1,2,3]'
+        client.should_receive(:execute).once.with 'insert into key_value values (?,?)', 'b', '[4,5,6]'
+
+        db.dump_sqlite :a => [1,2,3], :b => [4,5,6]
+      end
+    end
+
+    describe 'load' do
+      it 'returns a copy of itself' do
+        db.load.should == db
+      end
+    end
+
+    describe 'empty' do
+      it 'returns the container that is used for indexing' do
+        db.empty.should == db
+      end
+    end
+
+    describe 'initial' do
+      it 'is correct' do
+        db.initial.should == db
+      end
+    end
+
+    describe 'to_s' do
+      it 'returns the cache path with the default file extension' do
+        db.to_s.should == 'Picky::Backends::SQLite::Array(some/cache/path/to/file.sqlite3)'
+      end
+    end
+  end
+
+end

data/spec/lib/backends/sqlite/directly_manipulable_spec.rb

@@ -0,0 +1,65 @@
+require 'spec_helper'
+
+describe Picky::Backends::SQLite::DirectlyManipulable do
+
+  let(:client) { stub :client }
+  let(:backend) { stub :backend, client: client, namespace: 'some:namespace' }
+  let(:array) do
+    array = [1,2]
+    described_class.make backend, array, 'some:key'
+    array
+  end
+
+  context 'stubbed backend' do
+    before(:each) do
+      backend.stub! :[]
+    end
+    it 'calls the right client method' do
+      backend.should_receive(:[]=).once.with 'some:key', [1,2,3]
+
+      array << 3
+    end
+    it 'calls the right client method' do
+      backend.should_receive(:[]=).once.with 'some:key', [3,1,2]
+
+      array.unshift 3
+    end
+    it 'calls the right client method' do
+      backend.should_receive(:[]=).once.with 'some:key', [2]
+
+      array.delete 1
+    end
+    it 'calls the right client method' do
+      client.should_receive(:zrem).never
+
+      array.delete 5
+    end
+  end
+
+  context 'stubbed client/backend' do
+    before(:each) do
+      backend.stub! :[]=
+    end
+    it 'behaves like an ordinary Array' do
+      array << 3
+
+      array.should == [1,2,3]
+    end
+    it 'behaves like an ordinary Array' do
+      array.unshift 3
+
+      array.should == [3,1,2]
+    end
+    it 'behaves like an ordinary Array' do
+      array.delete 1
+
+      array.should == [2]
+    end
+    it 'behaves like an ordinary Array' do
+      array.delete 5
+
+      array.should == [1,2]
+    end
+  end
+
+end

data/spec/lib/backends/sqlite/{db_spec.rb → value_spec.rb}

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 require 'sqlite3'
 
-describe Picky::Backends::SQLite::DB do
+describe Picky::Backends::SQLite::Value do
 
   context 'hash-based indexes' do
     let(:db) { described_class.new 'some/cache/path/to/file' }
@@ -51,11 +51,6 @@ describe Picky::Backends::SQLite::DB do
       it 'returns a copy of itself' do
         db.load.should == db
       end
-      it 'initializes the client' do
-        db.should_receive(:lazily_initialize_client).once.with
-
-        db.load
-      end
     end
 
     describe 'empty' do
@@ -72,7 +67,7 @@ describe Picky::Backends::SQLite::DB do
 
     describe 'to_s' do
       it 'returns the cache path with the default file extension' do
-        db.to_s.should == 'Picky::Backends::SQLite::DB(some/cache/path/to/file.sqlite3)'
+        db.to_s.should == 'Picky::Backends::SQLite::Value(some/cache/path/to/file.sqlite3)'
       end
     end
   end

data/spec/lib/backends/sqlite_spec.rb

@@ -1,23 +1,25 @@
 require 'spec_helper'
 
+require 'sqlite3'
+
 describe Picky::Backends::SQLite do
 
   context 'with options' do
     before(:each) do
-      @backend = described_class.new inverted:      Picky::Backends::SQLite::DB.new(:unimportant),
-                                     weights:       Picky::Backends::SQLite::DB.new(:unimportant),
-                                     similarity:    Picky::Backends::SQLite::DB.new(:unimportant),
-                                     configuration: Picky::Backends::SQLite::DB.new(:unimportant)
+      @backend = described_class.new inverted:      Picky::Backends::SQLite::Value.new(:unimportant),
+                                     weights:       Picky::Backends::SQLite::Array.new(:unimportant),
+                                     similarity:    Picky::Backends::SQLite::Value.new(:unimportant),
+                                     configuration: Picky::Backends::SQLite::Array.new(:unimportant)
 
       @backend.stub! :timed_exclaim
     end
 
     describe 'create_...' do
       [
-        [:inverted,      Picky::Backends::SQLite::DB],
-        [:weights,       Picky::Backends::SQLite::DB],
-        [:similarity,    Picky::Backends::SQLite::DB],
-        [:configuration, Picky::Backends::SQLite::DB]
+        [:inverted,      Picky::Backends::SQLite::Value],
+        [:weights,       Picky::Backends::SQLite::Array],
+        [:similarity,    Picky::Backends::SQLite::Value],
+        [:configuration, Picky::Backends::SQLite::Array]
       ].each do |type, kind|
         it "creates and returns a(n) #{type} index" do
           @backend.send(:"create_#{type}",
@@ -30,20 +32,20 @@ describe Picky::Backends::SQLite do
 
   context 'with lambda options' do
     before(:each) do
-      @backend = described_class.new inverted:      ->(bundle){ Picky::Backends::SQLite::DB.new(bundle.index_path(:inverted)) },
-                                     weights:       ->(bundle){ Picky::Backends::SQLite::DB.new(bundle.index_path(:weights)) },
-                                     similarity:    ->(bundle){ Picky::Backends::SQLite::DB.new(bundle.index_path(:similarity)) },
-                                     configuration: ->(bundle){ Picky::Backends::SQLite::DB.new(bundle.index_path(:configuration)) }
+      @backend = described_class.new inverted:      ->(bundle){ Picky::Backends::SQLite::Value.new(bundle.index_path(:inverted)) },
+                                     weights:       ->(bundle){ Picky::Backends::SQLite::Array.new(bundle.index_path(:weights)) },
+                                     similarity:    ->(bundle){ Picky::Backends::SQLite::Value.new(bundle.index_path(:similarity)) },
+                                     configuration: ->(bundle){ Picky::Backends::SQLite::Array.new(bundle.index_path(:configuration)) }
 
       @backend.stub! :timed_exclaim
     end
 
     describe 'create_...' do
       [
-        [:inverted,      Picky::Backends::SQLite::DB],
-        [:weights,       Picky::Backends::SQLite::DB],
-        [:similarity,    Picky::Backends::SQLite::DB],
-        [:configuration, Picky::Backends::SQLite::DB]
+        [:inverted,      Picky::Backends::SQLite::Value],
+        [:weights,       Picky::Backends::SQLite::Array],
+        [:similarity,    Picky::Backends::SQLite::Value],
+        [:configuration, Picky::Backends::SQLite::Array]
       ].each do |type, kind|
         it "creates and returns a(n) #{type} index" do
           to_a_able_stub = Object.new
@@ -63,10 +65,10 @@ describe Picky::Backends::SQLite do
 
     describe 'create_...' do
       [
-        [:inverted,      Picky::Backends::SQLite::DB],
-        [:weights,       Picky::Backends::SQLite::DB],
-        [:similarity,    Picky::Backends::SQLite::DB],
-        [:configuration, Picky::Backends::SQLite::DB]
+        [:inverted,      Picky::Backends::SQLite::Array],
+        [:weights,       Picky::Backends::SQLite::Value],
+        [:similarity,    Picky::Backends::SQLite::Array],
+        [:configuration, Picky::Backends::SQLite::Value]
       ].each do |type, kind|
         it "creates and returns a(n) #{type} index" do
           @backend.send(:"create_#{type}",

data/spec/lib/category_indexed_spec.rb

@@ -160,7 +160,7 @@ describe Picky::Category do
 
     describe 'load' do
       it 'should call two methods' do
-        @category.should_receive(:clear_realtime_mapping).once
+        @category.should_receive(:clear_realtime).once
         @exact.should_receive(:load).once
         @partial.should_receive(:load).once
 

data/spec/lib/category_indexing_spec.rb

@@ -14,8 +14,8 @@ describe Picky::Category do
 
     describe 'clear' do
       it 'delegates to both bundles' do
-        exact.should_receive(:delete).once.with()
-        partial.should_receive(:delete).once.with()
+        exact.should_receive(:clear).once.with()
+        partial.should_receive(:clear).once.with()
 
         category.clear
       end

data/spec/lib/index_indexing_spec.rb

@@ -97,13 +97,6 @@ describe Picky::Index do
       @index.define_category :some_category_name1
       @index.define_category :some_category_name2
     end
-    describe "warn_no_source" do
-      it "should warn" do
-        @index.should_receive(:warn).once.with "No source given for index some_name."
-
-        @index.warn_no_source
-      end
-    end
     describe 'define_source' do
       it 'can be set with this method' do
         source = stub :source, :each => [].each

data/spec/lib/index_realtime_spec.rb

@@ -0,0 +1,34 @@
+# encoding: utf-8
+#
+require 'spec_helper'
+
+describe Picky::Index, "Realtime API" do
+
+  Thing = Struct.new :id, :text
+
+  let(:index) do
+    described_class.new :some_index_name do
+      category :text
+    end
+  end
+
+  it 'offers an add method' do
+    index.add Thing.new(1, 'text')
+  end
+  it 'offers a remove method' do
+    index.remove 1
+  end
+  it 'offers a replace method' do
+    index.replace Thing.new(1, 'text')
+  end
+  it 'offers a << method' do
+    index << Thing.new(1, 'text')
+  end
+  # it 'offers a >> method' do
+  #   Thing.new(1, 'text') >> index # I mean, as long as we're dreaming.
+  # end
+  it 'offers an unshift method' do
+    index.unshift Thing.new(1, 'text')
+  end
+
+end