prosto_cache 0.2.1 → 0.2.2

data/Gemfile

@@ -1,4 +1,4 @@
-source "http://rubygems.org"
+source 'https://rubygems.org'
 
 group :development do
   gem "rspec" #, "~> 2.3.0"

data/Gemfile.lock

@@ -1,5 +1,5 @@
 GEM
-  remote: http://rubygems.org/
+  remote: https://rubygems.org/
   specs:
     diff-lcs (1.2.4)
     rake (10.0.4)

data/README.rdoc

@@ -1,8 +1,10 @@
 = prosto_cache
 
-prosto_cache provides a simple way to cache enumeration-like models in memory and to access this cache in uniform way.
+{<img src="https://travis-ci.org/olek/prosto_cache.png?branch=master" alt="Build Status" />}[https://travis-ci.org/olek/prosto_cache]
 
-Here are couple thinks that it will NOT do for you.
+prosto_cache provides a simple way to cache enumeration-like models in memory and to access this cache in a uniform way.
+
+Here are a couple of things that it will NOT do for you.
 
 - it will not monkey patch rails in attempt to make itself 'totally' easy to use
 - it will not attempt to share/distribute cache
@@ -31,14 +33,14 @@ Usage:
     include ProstoCache
 2. Configure cache access keys (optional step, by default cache is accessed by key 'name')
   cache_accessor_keys %w(scope name)
-3. Your model MUST have non-nullable column updated_at, add new migration with it if missing
+3. Your model MUST have a non-nullable column updated_at, add new migration with it if missing
     (this field is used for invalidating cache in other ruby processes)
 4. Access cached model object in your code like this
 * Simple case of one key
 
     YourModel.cache[:key1]
 * Case of 2 or more keys where it is known ahead of time that all parent keys exist.
-  Looks conventional, but is not quite unreliable because brackets operation on nil will raise an error.
+  Looks conventional, but is not quite reliable because brackets operation on nil will raise an error.
   If you know a good way to make it reliable, let me know!
 
     YourModel.cache[:key1][:key2][:key3]

data/lib/prosto_cache/extensions.rb

@@ -0,0 +1,17 @@
+module ProstoCache
+  module Extensions
+    def lookup_enum_for(name, enum_class=nil)
+      raise ArgumentError, "No name provided" unless name
+      enum_class = name.to_s.classify.constantize unless enum_class
+      define_method("#{name}_with_lookup=") do |o|
+        new_value = o
+        unless o.is_a?(enum_class)
+          new_value = o.blank? ? nil : enum_class[o.to_s]
+        end
+        self.send("#{name}_without_lookup=", new_value)
+      end
+
+      alias_method_chain "#{name}=", :lookup
+    end
+  end
+end

data/lib/prosto_cache/prosto_hash.rb

@@ -0,0 +1,43 @@
+module ProstoCache
+  class ProstoHash
+    extend Forwardable
+    def initialize(hash = {})
+      @hash = hash.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v }
+    end
+
+    def [](key)
+      raise ArgumentError unless key
+      hash[key.to_sym]
+    end
+
+    def []=(key, value)
+      raise ArgumentError unless key
+      hash[key.to_sym] = value
+    end
+
+    def keys(init = nil)
+      @keys = @keys || init || hash.keys
+    end
+
+    def values(init = nil)
+      @values = @values || init || hash.values
+    end
+
+    def_delegators :hash, :to_s, :inspect
+
+    private
+
+    attr_reader :hash
+  end
+
+  def self.fail_on_missing_value?(litmus)
+    case litmus
+    when Symbol
+      true
+    when String
+      false
+    else
+      raise ArgumentError, "Unknown type of cache key #{litmus.inspect}"
+    end
+  end
+end

data/lib/prosto_cache/prosto_model_cache.rb

@@ -0,0 +1,225 @@
+=begin
+This library provides a simple way to cache model and to access this cache in some canonical way.
+Any changes to the model's objects will automatically result in cache reload.
+Cache reload in other ruby processes of same app will be triggered as well, but
+with some delay (currently up to 60 seconds).
+If the delay in cache reloading is not an option, well, this simple library will
+not work for you, and you will have to use something fancier, like Memcached.
+
+Usage:
+
+* Add ProstoCache mixin to your model
+  class YourModel < ActiveRecord::Base
+    include ProstoCache
+
+* Configure cache access keys (optional step, by default cache is accessed by key 'name')
+  cache_accessor_keys %w(scope name)
+
+* Your model must have non-nullable column updated_at, add it in migration if
+  it is missing (this field is used for invalidating cache in other ruby processes).
+
+* Access cached model object in your code like this
+  Simple case of one key
+    YourModel.cache[:key1]
+  Case of 2 or more keys
+    YourModel.cache[:key1, :key2, :key3]
+
+* Handling of non-existing cache values.
+  If cache is accessed using symbol key and value not found, it will raise BadCacheKeyError.
+  If cache is accessed using string key and value not found, it will return nil.
+  For complex keys type of last key component is the one taken into account.
+
+* If you want to, you can add extra lookup helpers to the objects that relate
+  to the cached object, that will allow those objects to update 'string'
+  attribute, and that will result in database reference change.
+    class OtherModel < ActiveRecord::Base
+      belongs_to :your_model
+      lookup_enum_for :your_model
+    end
+
+  This lookup was intertionally not integrated 'seamlessly' with ActiveRecord since not
+  everybody would want that, and monkey-patching other library (AR) is not really
+  a good thing, even if it results in a 'smoother' experience where everything works as if by magic.
+=end
+
+module ProstoCache
+  class BadCacheKeyError < StandardError; end
+  class BadCacheValuesError < StandardError; end
+
+  # cache itself, contains pretty much all the logic
+  class ProstoModelCache
+
+    def self.fail_on_missing_value?(litmus)
+      case litmus
+      when Symbol
+        true
+      when String
+        false
+      else
+        raise ArgumentError, "Unknown type of cache key #{litmus.inspect}"
+      end
+    end
+
+    MAX_CACHE_LIFE = 60 # seconds
+
+    def initialize(model_class, accessor_keys, sort_keys)
+      raise ArgumentError, "No model class provided" unless model_class
+
+      @model_class = model_class
+      @accessor_keys = [*(accessor_keys || :name)]
+      @sort_keys = sort_keys ? [*(sort_keys)] : @accessor_keys
+    end
+
+    def invalidate
+      self.cache = self.signature = self.validated_at = nil
+    end
+
+    def [](*keys)
+      unless keys.length == accessor_keys.length
+        raise BadCacheKeyError, "Cached accessed by #{keys.length} keys, expected #{accessor_keys.length}"
+      end
+
+      keys.zip((1..keys.length)).inject(safe_cache) do |memo, (key, index)|
+        value = memo[key]
+        unless value
+          if ProstoModelCache.fail_on_missing_value?(keys.last)
+            raise BadCacheKeyError, key
+          else
+            value = ProstoHash.new unless index == keys.length
+          end
+        end
+
+        value
+      end
+    end
+
+    def keys
+      safe_cache.keys
+    end
+
+    def values
+      safe_cache.values
+    end
+
+    private
+
+    attr_reader :model_class, :cache, :signature, :validated_at, :accessor_keys, :sort_keys
+    attr_writer :cache, :signature, :validated_at
+
+    def safe_cache
+      time = Time.now.to_i
+
+      if cache && validated_at < time - MAX_CACHE_LIFE
+        current_cache_signature = validate_cache_signature(time)
+      end
+
+      unless cache
+        load_cache(time, current_cache_signature)
+      end
+
+      cache
+    end
+
+    def validate_cache_signature(time)
+      query_cache_signature.tap { |current_cache_signature|
+        if current_cache_signature == signature
+          self.validated_at = time
+        else
+          invalidate
+        end
+      }
+    end
+
+    def load_cache(time, current_cache_signature = nil)
+      fail "Can not load already loaded cache" if cache
+
+      current_cache_signature ||= query_cache_signature
+
+      cache_values = model_class.all
+      self.cache = build_cache(cache_values, accessor_keys)
+      cache.values(sorted_cache_values(cache_values))
+      cache.keys(sorted_keys(cache.values))
+      self.validated_at = time
+      self.signature = current_cache_signature
+    end
+
+
+    def build_cache(objects, attributes=[])
+      attributes = [*attributes]
+      if attributes.empty?
+        # terminal case
+        raise BadCacheValuesError, "No cache entry found" if objects.nil? || objects.empty?
+        raise BadCacheValuesError, "Non deterministic search result, more then one cache entry found" if objects.size > 1
+        return objects.first
+      else
+        reduced_attributes = attributes.dup
+        attribute = reduced_attributes.delete_at(0).to_sym
+        # first, bucketize to reduce problem's complexity
+        array_map = objects.each_with_object({}) do |o, memo|
+          key = o.public_send(attribute).to_s
+          memo[key] ||= []
+          memo[key] << o
+        end
+        # second, recurse and build cache from those reduced buckets!
+        array_map.each_with_object(ProstoHash.new) do |(attr_value, attr_bucket), memo|
+          memo[attr_value] = build_cache(attr_bucket, reduced_attributes)
+        end
+      end
+    end
+
+    def sorted_cache_values(cache_values)
+      cache_values.sort_by { |o|
+        sort_keys.inject('') { |memo, k|
+          memo << o.public_send(k)
+        }
+      }
+    end
+
+    def sorted_keys(cache_values)
+      cache_values.map { |o|
+        accessor_keys.inject([]) { |memo, k|
+          memo << o.public_send(k).to_sym
+        }
+      }.tap { |rtn|
+        rtn.flatten! if accessor_keys.length == 1
+      }
+    end
+
+    def query_cache_signature
+      raw_result = ActiveRecord::Base.connection.execute(
+        "select max(updated_at) as max_updated_at, max(id) as max_id, count(id) as count from #{model_class.table_name}"
+      )
+      array_result = case raw_result.class.name
+      when 'Mysql::Result'
+        [].tap { |rows| raw_result.each_hash { |h| rows << h } }
+      when 'Mysql2::Result'
+        [].tap { |rows| raw_result.each(:as => :hash) { |h| rows << h } }
+      when 'PGresult'
+        raw_result.map(&:to_hash)
+      else
+        fail "Result class #{raw_result.class.name} in unsupported"
+      end
+      array_result.map(&:symbolize_keys).first
+    end
+  end
+
+  def self.included(cl)
+
+    cl.after_save { cl.cache.invalidate }
+
+    class << cl
+
+      def cache
+        @cache ||= ProstoModelCache.new self, @accessor_keys, @sort_keys
+      end
+
+      def cache_accessor_keys(keys)
+        @accessor_keys = keys
+      end
+
+      def cache_sort_keys(keys)
+        @sort_keys = keys
+      end
+    end
+  end
+end

data/lib/prosto_cache.rb

@@ -1,238 +1,3 @@
-=begin
-This library provides a simple way to cache model and to access this cache in some canonical way.
-Any changes to the model's objects will automatically result in cache reload.
-Cache reload in other ruby processes of same app will be triggered as well, but
-with some delay (currently up to 60 seconds).
-If delay in cache reloading is not an option, well, this simply library will
-not work for you, and you have to use something fancier, like Memcached.
-
-Usage:
-
-* Add ProstoCache mixin to your model
-  class YourModel < ActiveRecord::Base
-    include ProstoCache
-
-* Configure cache access keys (optional step, by default cache is accessed by key 'name')
-  cache_accessor_keys %w(scope name)
-
-* Your model must have non-nullable column updated_at, add it in migration if
-  it is missing (this field is used for invalidating cache in other ruby processes).
-
-* Access cached model object in your code like this
-  Simple case of one key
-    YourModel.cache[:key1]
-  Case of 2 or more keys
-    YourModel.cache[:key1, :key2, :key3]
-
-* Handling of non-existing cache values.
-  If cache is accessed using symbol key and value not found, it will raise BadCacheKeyError.
-  If cache is accessed using string key and value not found, it will return nil.
-  For complex keys type of last key component is the one taken into account.
-
-* If you want to, you can add extra lookup helpers to the objects that relate
-  to the cached object, that will allow those objects to update 'string'
-  attribute, and that will result in database reference change.
-    class OtherModel < ActiveRecord::Base
-      belongs_to :your_model
-      lookup_enum_for :your_model
-    end
-
-  This lookup was intertionally not integrated 'seamlessly' with ActiveRecord since not
-  everybody would want that, and monkey-patching other library (AR) is not really
-  a good thing, even if it results in more 'smooth' experience where everything works as if by magic.
-=end
-
-module ProstoCache
-  class BadCacheKeyError < StandardError; end
-  class BadCacheValuesError < StandardError; end
-
-  # cache itself, contains pretty much all the logic
-  class ProstoModelCache
-
-    class ProstoHash
-      extend Forwardable
-      def initialize(hash = {})
-        @hash = hash.each_with_object({}) { |(k, v), memo| memo[k.to_sym] = v }
-      end
-
-      def [](key)
-        raise ArgumentError unless key
-        hash[key.to_sym]
-      end
-
-      def []=(key, value)
-        raise ArgumentError unless key
-        hash[key.to_sym] = value
-      end
-
-      def_delegators :hash, :to_s, :inspect, :keys, :values
-
-      private
-
-      attr_reader :hash
-    end
-
-    def self.fail_on_missing_value?(litmus)
-      case litmus
-      when Symbol
-        true
-      when String
-        false
-      else
-        raise ArgumentError, "Unknown type of cache key #{litmus.inspect}"
-      end
-    end
-
-    MAX_CACHE_LIFE = 60 # seconds
-
-    def initialize(model_class, accessor_keys)
-      raise ArgumentError, "No model class provided" unless model_class
-
-      @model_class = model_class
-      @accessor_keys = [*(accessor_keys || :name)]
-    end
-
-    def invalidate
-      self.cache = self.signature = self.validated_at = nil
-    end
-
-    def [](*keys)
-      unless keys.length == accessor_keys.length
-        raise BadCacheKeyError, "Cached accessed by #{keys.length} keys, expected #{accessor_keys.length}"
-      end
-
-      keys.zip((1..keys.length)).inject(safe_cache) do |memo, (key, index)|
-        value = memo[key]
-        unless value
-          if ProstoModelCache.fail_on_missing_value?(keys.last)
-            raise BadCacheKeyError, key
-          else
-            value = ProstoHash.new unless index == keys.length
-          end
-        end
-
-        value
-      end
-    end
-
-    def keys
-      safe_cache.keys
-    end
-
-    def values
-      safe_cache.values
-    end
-
-    private
-
-    attr_reader :model_class, :cache, :signature, :validated_at, :accessor_keys
-    attr_writer :cache, :signature, :validated_at
-
-    def safe_cache
-      time = Time.now.to_i
-
-      if cache && validated_at < time - MAX_CACHE_LIFE
-        current_cache_signature = validate_cache_signature(time)
-      end
-
-      unless cache
-        load_cache(time, current_cache_signature)
-      end
-
-      cache
-    end
-
-    def validate_cache_signature(time)
-      query_cache_signature.tap { |current_cache_signature|
-        if current_cache_signature == signature
-          self.validated_at = time
-        else
-          invalidate
-        end
-      }
-    end
-
-    def load_cache(time, current_cache_signature = nil)
-      fail "Can not load already loaded cache" if cache
-
-      current_cache_signature ||= query_cache_signature
-
-      self.cache = build_cache(model_class.all, accessor_keys)
-      self.validated_at = time
-      self.signature = current_cache_signature
-    end
-
-
-    def build_cache(objects, attributes=[])
-      attributes = [*attributes]
-      if attributes.empty?
-        # terminal case
-        raise BadCacheValuesError, "No cache entry found" if objects.nil? || objects.empty?
-        raise BadCacheValuesError, "Non deterministic search result, more then one cache entry found" if objects.size > 1
-        return objects.first
-      else
-        reduced_attributes = attributes.dup
-        attribute = reduced_attributes.delete_at(0).to_sym
-        # first, bucketize to reduce problem's complexity
-        array_map = objects.each_with_object({}) do |o, memo|
-          key = o.send(attribute).to_s
-          memo[key] ||= []
-          memo[key] << o
-        end
-        # second, recurse and build cache from those reduced buckets!
-        array_map.each_with_object(ProstoHash.new) do |(attr_value, attr_bucket), memo|
-          memo[attr_value] = build_cache(attr_bucket, reduced_attributes)
-        end
-      end
-    end
-
-    def query_cache_signature
-      raw_result = ActiveRecord::Base.connection.execute(
-        "select max(updated_at) as max_updated_at, max(id) as max_id, count(id) as count from #{model_class.table_name}"
-      )
-      array_result = case raw_result.class.name
-      when 'Mysql::Result'
-        [].tap { |rows| raw_result.each_hash { |h| rows << h } }
-      when 'Mysql2::Result'
-        [].tap { |rows| raw_result.each(:as => :hash) { |h| rows << h } }
-      when 'PGresult'
-        raw_result.map(&:to_hash)
-      else
-        fail "Result class #{raw_result.class.name} in unsupported"
-      end
-      array_result.map(&:symbolize_keys).first
-    end
-  end
-
-  def self.included(cl)
-
-    cl.after_save { cl.cache.invalidate }
-
-    class << cl
-
-      def cache
-        @cache ||= ProstoModelCache.new self, @accessor_keys
-      end
-
-      def cache_accessor_keys(keys)
-        @accessor_keys = keys
-      end
-    end
-  end
-
-  module Extensions
-    def lookup_enum_for(name, enum_class=nil)
-      raise ArgumentError, "No name provided" unless name
-      enum_class = name.to_s.classify.constantize unless enum_class
-      define_method("#{name}_with_lookup=") do |o|
-        new_value = o
-        unless o.is_a?(enum_class)
-          new_value = o.blank? ? nil : enum_class[o.to_s]
-        end
-        self.send("#{name}_without_lookup=", new_value)
-      end
-
-      alias_method_chain "#{name}=", :lookup
-    end
-  end
-end
+require 'prosto_cache/prosto_hash'
+require 'prosto_cache/prosto_model_cache'
+require 'prosto_cache/extensions'

data/spec/prosto_cache_spec.rb

@@ -8,12 +8,12 @@ describe "Model with prosto cache mixed in" do
     }
   }
 
-  describe '#cache' do
-    it "should add a cache method" do
-      model_class.cache.should_not be_nil
-      model_class.cache.should be_an_instance_of(ProstoCache::ProstoModelCache)
-    end
+  it "should have cache method" do
+    model_class.cache.should_not be_nil
+    model_class.cache.should be_an_instance_of(ProstoCache::ProstoModelCache)
+  end
 
+  describe '.cache' do
     it "should not load cache if it was never accessed" do
       model_class.cache.should_not_receive(:query_cache_signature)
       model_class.should_not_receive(:all)
@@ -21,8 +21,10 @@ describe "Model with prosto cache mixed in" do
       model_class.cache.should_not be_nil
     end
   end
+end
 
-  describe 'cache' do
+describe ProstoCache::ProstoModelCache do
+  context "with single key access" do
     let(:model_class) {
       Class.new {
         def self.after_save; end
@@ -41,7 +43,7 @@ describe "Model with prosto cache mixed in" do
 
     describe "#keys" do
       it "should return all keys from the cache" do
-        model_class.cache.keys.should == [:foo, :bar]
+        model_class.cache.keys.should == [:bar, :foo]
       end
     end
 
@@ -49,42 +51,119 @@ describe "Model with prosto cache mixed in" 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)
+        # values.map(&:name).should == %w(foo bar)
+        values.map(&:name).should include('foo')
+        values.map(&:name).should include('bar')
+      end
+
+      it "should sort values by accessor key" do
+        values = model_class.cache.values
+        values.map(&:name).should == %w(bar foo)
+      end
+
+      context 'when sort_keys are provided' do
+        let(:model_class) {
+          Class.new {
+            def self.after_save; end
+
+            include ProstoCache
+
+            cache_sort_keys(:reversed_name)
+
+            attr_accessor :name
+            def initialize(name)
+              self.name = name
+            end
+
+            def reversed_name
+              name.reverse
+            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) })
+          }
+        }
+
+        it "should sort values by sort key" do
+          values = model_class.cache.values
+          values.map(&:name).should == %w(foo bar)
+        end
       end
     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 load cache when it is accessed" do
+        model_class.should_receive(:all).once.and_return(%w(foo bar).map { |n| model_class.new(n) })
+
+        model_class.cache[:foo]
+      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
 
-          model_class.cache[:foo]
+        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 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
+      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 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
+        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
+  end
+
+  context "with composite key access" do
+    let(:model_class) {
+      Class.new {
+        def self.after_save; 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
+        include ProstoCache
 
-          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
+        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') })
+      }
+    }
+
+    describe "#keys" do
+      it "should return all keys from the cache as array of arrays" do
+        model_class.cache.keys.should == [[:bar1, :bar2], [:foo1, :foo2]]
       end
+    end
 
-      context "with composite key access" do
+    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)
+        values.map(&:name).should include('foo')
+        values.map(&:name).should include('bar')
+      end
+
+      it "should sort values by accessor keys" do
+        values = model_class.cache.values
+        values.map(&:name).should == %w(bar foo)
+      end
+
+      context 'when sort_keys are provided' do
         let(:model_class) {
           Class.new {
             def self.after_save; end
@@ -92,6 +171,7 @@ describe "Model with prosto cache mixed in" do
             include ProstoCache
 
             cache_accessor_keys %w(key1 key2)
+            cache_sort_keys(%w(reversed_name key1 key2))
 
             attr_accessor :name, :key1, :key2
             def initialize(name, key1, key2)
@@ -99,58 +179,69 @@ describe "Model with prosto cache mixed in" do
               self.key1 = key1
               self.key2 = key2
             end
+
+            def reversed_name
+              name.reverse
+            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
+        it "should sort values by sort keys" do
+          values = model_class.cache.values
+          values.map(&:name).should == %w(foo bar)
+        end
+      end
+    end
+
+    describe "#[]" do
+      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
+
+      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
+
+      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 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
+        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
+
+      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
 
-        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
+        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
 
-        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
+        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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: prosto_cache
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2011-05-23 00:00:00.000000000 Z
+date: 2013-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -18,7 +18,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.13'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: '2.3'
+        version: '2.13'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -43,41 +43,25 @@ dependencies:
     - - ~>
       - !ruby/object:Gem::Version
         version: '1.1'
-- !ruby/object:Gem::Dependency
-  name: rake
-  requirement: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    none: false
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
 description: Use this gem if you want a simple 'enum-like' cache for your models that
   does not restrict updates, but will stay current with them.
 email: olek@woodenbits.com
 executables: []
 extensions: []
-extra_rdoc_files:
-- LICENSE.txt
-- README.rdoc
+extra_rdoc_files: []
 files:
-- .rspec
+- lib/prosto_cache/extensions.rb
+- lib/prosto_cache/prosto_hash.rb
+- lib/prosto_cache/prosto_model_cache.rb
+- lib/prosto_cache.rb
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
-- README.rdoc
 - Rakefile
-- lib/prosto_cache.rb
-- prosto_cache.gemspec
+- README.rdoc
 - spec/prosto_cache_spec.rb
 - spec/spec_helper.rb
+- .rspec
 homepage: http://github.com/olek/prosto_cache
 licenses:
 - MIT
@@ -90,17 +74,19 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.9.3
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
   - - ! '>='
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.6
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Very simple caching for your ActiveRecord models.
-test_files: []
+test_files:
+- spec/prosto_cache_spec.rb
+- spec/spec_helper.rb

data/prosto_cache.gemspec

@@ -1,51 +0,0 @@
-# encoding: utf-8
-
-Gem::Specification.new do |s|
-  s.name = "prosto_cache"
-  s.version = "0.2.1"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Olek Poplavsky"]
-  s.date = "2011-05-23"
-  s.description = "Use this gem if you want a simple 'enum-like' cache for your models that does not restrict updates, but will stay current with them."
-  s.email = "olek@woodenbits.com"
-  s.extra_rdoc_files = [
-    "LICENSE.txt",
-    "README.rdoc"
-  ]
-  s.files = [
-    ".rspec",
-    "Gemfile",
-    "Gemfile.lock",
-    "LICENSE.txt",
-    "README.rdoc",
-    "Rakefile",
-    "lib/prosto_cache.rb",
-    "prosto_cache.gemspec",
-    "spec/prosto_cache_spec.rb",
-    "spec/spec_helper.rb",
-  ]
-  s.homepage = "http://github.com/olek/prosto_cache"
-  s.licenses = ["MIT"]
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.11"
-  s.summary = "Very simple caching for your ActiveRecord models."
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 3
-
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_development_dependency(%q<rspec>, ["~> 2.3"])
-      s.add_development_dependency(%q<bundler>, ["~> 1.1"])
-      s.add_development_dependency(%q<rake>)
-    else
-      s.add_dependency(%q<rspec>, ["~> 2.3"])
-      s.add_dependency(%q<bundler>, ["~> 1.1"])
-      s.add_dependency(%q<rake>)
-    end
-  else
-    s.add_dependency(%q<rspec>, ["~> 2.3"])
-    s.add_dependency(%q<bundler>, ["~> 1.1"])
-    s.add_dependency(%q<rake>)
-  end
-end