prosto_cache 0.2.0 → 0.2.1

data/lib/prosto_cache.rb

@@ -65,7 +65,7 @@ module ProstoCache
         hash[key.to_sym] = value
       end
 
-      def_delegators :hash, :to_s, :inspect
+      def_delegators :hash, :to_s, :inspect, :keys, :values
 
       private
 

data/prosto_cache.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = "prosto_cache"
-  s.version = "0.2.0"
+  s.version = "0.2.1"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Olek Poplavsky"]

data/spec/prosto_cache_spec.rb

@@ -1,140 +1,157 @@
 require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
 
-describe "ProstoCache" do
-  before do
-    Object.send(:remove_const, 'Foo') if Object.const_defined? 'Foo'
-
-    class Foo; end
-    Foo.stub(:after_save)
-  end
+describe "Model with prosto cache mixed in" do
+  let(:model_class) {
+    Class.new {
+      def self.after_save; end
+      include ProstoCache
+    }
+  }
 
   describe '#cache' do
-    before do
-      class Foo
-        include ProstoCache
-      end
-    end
-
     it "should add a cache method" do
-      Foo.cache.should_not be_nil
-      Foo.cache.should be_an_instance_of(ProstoCache::ProstoModelCache)
+      model_class.cache.should_not be_nil
+      model_class.cache.should be_an_instance_of(ProstoCache::ProstoModelCache)
     end
 
     it "should not load cache if it was never accessed" do
-      Foo.cache.should_not_receive(:query_cache_signature)
-      Foo.should_not_receive(:all)
+      model_class.cache.should_not_receive(:query_cache_signature)
+      model_class.should_not_receive(:all)
 
-      Foo.cache.should_not be_nil
+      model_class.cache.should_not be_nil
     end
   end
 
-  context "[] method with single key access" do
-    before do
-      class Foo
+  describe 'cache' do
+    let(:model_class) {
+      Class.new {
+        def self.after_save; end
+
         include ProstoCache
 
         attr_accessor :name
         def initialize(name)
           self.name = name
         end
+      }.tap { |model_class|
+        model_class.cache.stub(:query_cache_signature).once.and_return(:something)
+        model_class.stub(:all).once.and_return(%w(foo bar).map { |n| model_class.new(n) })
+      }
+    }
+
+    describe "#keys" do
+      it "should return all keys from the cache" do
+        model_class.cache.keys.should == [:foo, :bar]
       end
-
-      Foo.cache.stub(:query_cache_signature).once.and_return(:foo)
-      Foo.stub(:all).once.and_return(%w(foo bar).map { |n| Foo.new(n) })
     end
 
-    it "should load cache when it is accessed" do
-      Foo.should_receive(:all).once.and_return(%w(foo bar).map { |n| Foo.new(n) })
-
-      Foo.cache[:foo]
-    end
-
-    context 'when key is symbol' do
-      it "should raise an error for key that was not found" do
-        expect { Foo.cache[:nondef] }.to raise_error ProstoCache::BadCacheKeyError
-      end
-
-      it "should return proper object for key that was found" do
-        Foo.cache[:foo].should_not be_nil
-        Foo.cache[:foo].name.should == 'foo'
+    describe "#values" do
+      it "should return all values from the cache" do
+        values = model_class.cache.values
+        values.should have(2).instances
+        values.map(&:name).should == %w(foo bar)
       end
     end
 
-    context 'when key is string' do
-      it "should return nil for key that was not found" do
-        Foo.cache['nondef'].should be_nil
-      end
+    describe "#[]" do
+      context "with single key access" do
+        it "should load cache when it is accessed" do
+          model_class.should_receive(:all).once.and_return(%w(foo bar).map { |n| model_class.new(n) })
 
-      it "should return proper object for key that was found" do
-        Foo.cache['foo'].should_not be_nil
-        Foo.cache['foo'].name.should == 'foo'
-      end
-    end
-  end
-
-  context "[] method with composite key access" do
-    before do
-      class Foo
-        include ProstoCache
-        cache_accessor_keys %w(key1 key2)
-
-        attr_accessor :name, :key1, :key2
-        def initialize(name, key1, key2)
-          self.name = name
-          self.key1 = key1
-          self.key2 = key2
+          model_class.cache[:foo]
         end
-      end
 
-      Foo.cache.stub(:query_cache_signature).once.and_return(:foo)
-      Foo.stub(:all).once.and_return(%w(foo bar).map { |n| Foo.new(n, n + '1', n + '2') })
-    end
+        context 'when key is symbol' do
+          it "should raise an error for key that was not found" do
+            expect { model_class.cache[:nondef] }.to raise_error ProstoCache::BadCacheKeyError
+          end
 
-    it "should raise an error when not enough keys provided" do
-      expect { Foo.cache[:nondef] }.to raise_error ProstoCache::BadCacheKeyError
-      expect { Foo.cache[:foo1] }.to raise_error ProstoCache::BadCacheKeyError
-      expect { Foo.cache['nondef'] }.to raise_error ProstoCache::BadCacheKeyError
-      expect { Foo.cache['foo1'] }.to raise_error ProstoCache::BadCacheKeyError
-    end
-
-    it "should raise an error when too many keys provided" do
-      expect { Foo.cache[:nondef1, :nondef2, :nondef3] }.to raise_error ProstoCache::BadCacheKeyError
-      expect { Foo.cache[:foo1, :foo2, :nondef] }.to raise_error ProstoCache::BadCacheKeyError
-      expect { Foo.cache['nondef1', 'nondef2', 'nondef3'] }.to raise_error ProstoCache::BadCacheKeyError
-      expect { Foo.cache['foo1', 'foo2', 'nondef'] }.to raise_error ProstoCache::BadCacheKeyError
-    end
+          it "should return proper object for key that was found" do
+            model_class.cache[:foo].should_not be_nil
+            model_class.cache[:foo].name.should == 'foo'
+          end
+        end
 
-    context 'when last key is symbol' do
-      it "should raise an error for first key that was not found" do
-        expect { Foo.cache[:undef, :foo2] }.to raise_error ProstoCache::BadCacheKeyError
-        expect { Foo.cache['undef', :foo2] }.to raise_error ProstoCache::BadCacheKeyError
-      end
+        context 'when key is string' do
+          it "should return nil for key that was not found" do
+            model_class.cache['nondef'].should be_nil
+          end
 
-      it "should raise an error for last key that was not found" do
-        expect { Foo.cache[:foo1, :nondef] }.to raise_error ProstoCache::BadCacheKeyError
-        expect { Foo.cache['foo1', :nondef] }.to raise_error ProstoCache::BadCacheKeyError
+          it "should return proper object for key that was found" do
+            model_class.cache['foo'].should_not be_nil
+            model_class.cache['foo'].name.should == 'foo'
+          end
+        end
       end
 
-      it "should return proper object for key that was found" do
-        Foo.cache[:foo1, :foo2].should_not be_nil
-        Foo.cache[:foo1, :foo2].name.should == 'foo'
-      end
-    end
+      context "with composite key access" do
+        let(:model_class) {
+          Class.new {
+            def self.after_save; end
+
+            include ProstoCache
+
+            cache_accessor_keys %w(key1 key2)
+
+            attr_accessor :name, :key1, :key2
+            def initialize(name, key1, key2)
+              self.name = name
+              self.key1 = key1
+              self.key2 = key2
+            end
+          }.tap { |model_class|
+            model_class.cache.stub(:query_cache_signature).once.and_return(:foo)
+            model_class.stub(:all).once.and_return(%w(foo bar).map { |n| model_class.new(n, n + '1', n + '2') })
+          }
+        }
+
+        it "should raise an error when not enough keys provided" do
+          expect { model_class.cache[:nondef] }.to raise_error ProstoCache::BadCacheKeyError
+          expect { model_class.cache[:foo1] }.to raise_error ProstoCache::BadCacheKeyError
+          expect { model_class.cache['nondef'] }.to raise_error ProstoCache::BadCacheKeyError
+          expect { model_class.cache['foo1'] }.to raise_error ProstoCache::BadCacheKeyError
+        end
 
-    context 'when last key is string' do
-      it "should return nil for first level key that was not found" do
-        Foo.cache['nondef', 'foo2'].should be_nil
-        Foo.cache[:nondef, 'foo2'].should be_nil
-      end
+        it "should raise an error when too many keys provided" do
+          expect { model_class.cache[:nondef1, :nondef2, :nondef3] }.to raise_error ProstoCache::BadCacheKeyError
+          expect { model_class.cache[:foo1, :foo2, :nondef] }.to raise_error ProstoCache::BadCacheKeyError
+          expect { model_class.cache['nondef1', 'nondef2', 'nondef3'] }.to raise_error ProstoCache::BadCacheKeyError
+          expect { model_class.cache['foo1', 'foo2', 'nondef'] }.to raise_error ProstoCache::BadCacheKeyError
+        end
 
-      it "should return nil for second level key that was not found" do
-        Foo.cache['foo1', 'nondef'].should be_nil
-        Foo.cache[:foo1, 'nondef'].should be_nil
-      end
+        context 'when last key is symbol' do
+          it "should raise an error for first key that was not found" do
+            expect { model_class.cache[:undef, :foo2] }.to raise_error ProstoCache::BadCacheKeyError
+            expect { model_class.cache['undef', :foo2] }.to raise_error ProstoCache::BadCacheKeyError
+          end
+
+          it "should raise an error for last key that was not found" do
+            expect { model_class.cache[:foo1, :nondef] }.to raise_error ProstoCache::BadCacheKeyError
+            expect { model_class.cache['foo1', :nondef] }.to raise_error ProstoCache::BadCacheKeyError
+          end
+
+          it "should return proper object for key that was found" do
+            model_class.cache[:foo1, :foo2].should_not be_nil
+            model_class.cache[:foo1, :foo2].name.should == 'foo'
+          end
+        end
 
-      it "should return proper object for key that was found" do
-        Foo.cache['foo1', 'foo2'].should_not be_nil
-        Foo.cache['foo1', 'foo2'].name.should == 'foo'
+        context 'when last key is string' do
+          it "should return nil for first level key that was not found" do
+            model_class.cache['nondef', 'foo2'].should be_nil
+            model_class.cache[:nondef, 'foo2'].should be_nil
+          end
+
+          it "should return nil for second level key that was not found" do
+            model_class.cache['foo1', 'nondef'].should be_nil
+            model_class.cache[:foo1, 'nondef'].should be_nil
+          end
+
+          it "should return proper object for key that was found" do
+            model_class.cache['foo1', 'foo2'].should_not be_nil
+            model_class.cache['foo1', 'foo2'].name.should == 'foo'
+          end
+        end
       end
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prosto_cache
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
   prerelease: 
 platform: ruby
 authors:
@@ -99,7 +99,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Very simple caching for your ActiveRecord models.