object_cache 0.0.3 → 0.0.4

data/lib/object_cache/cache_store.rb

@@ -0,0 +1,52 @@
+class ObjectCache
+  class CacheStore
+    class << self
+      
+      def fetch(klass, ids)
+        raise NotImplementedError
+      end
+
+      def get(klass, id)
+        raise NotImplementedError
+      end
+
+      def set(klass, id, value)
+        raise NotImplementedError
+      end
+
+      def hash_get(key)
+        raise NotImplementedError
+      end
+
+      def hash_set(key, value)
+        raise NotImplementedError
+      end
+
+      def fetch_from_array(klass, ids)
+        ObjectCache.constantize(klass).find(ids)
+      end
+
+      def fetch_fresh_results(klass, to_set)
+        #puts to_set.inspect
+        return nil if to_set.size == 0
+        results = []
+        fresh_results = fetch_from_array(klass, to_set)
+
+        fresh_results.each do |item|
+          results << set(klass, item.id, item)
+        end
+
+        results
+      end
+
+      def array_or_value(results, ids)
+        if ids.class == Array
+          results
+        else
+          results.first
+        end
+      end
+
+    end
+  end
+end

data/lib/object_cache/class_cacher.rb

@@ -0,0 +1,14 @@
+class ObjectCache
+  class ClassCacher
+    @@cache = {}
+
+    def self.cache(klass, id)
+      ObjectCache.cache_store.fetch(klass, id)
+    end
+
+    def self.get_cache
+      @@cache
+    end
+
+  end
+end

data/lib/object_cache/memory_store.rb

@@ -0,0 +1,55 @@
+require "object_cache/cache_store"
+
+class ObjectCache
+  class MemoryStore < ObjectCache::CacheStore
+    @@cache = {}
+    @@hash = {}
+
+    def self.fetch(klass, ids)
+      results = []
+      to_set = []
+      [*ids].each do |id|
+        if @@cache[klass] && @@cache[klass][id] && (Time.now - @@cache[klass][id].last) < ObjectCache.ttl
+          results << get(klass, id)
+        else
+          to_set << id
+        end
+      end
+
+      fresh_results = fetch_fresh_results(klass, to_set)
+      results += fresh_results if fresh_results
+      results.compact!
+
+      # if we're asking for one object, we want it,
+      # if asking for array, we expect array of objects back
+      if ids.class == Array
+        results
+      else
+        results.first
+      end
+    end
+
+    def self.get(klass, id)
+      @@cache[klass][id].first
+    end
+
+    def self.set(klass, id, item)
+      @@cache[klass] ||= {}
+      @@cache[klass][id] = [item, Time.now]
+      @@cache[klass][id].first
+    end
+
+    def self.hash_empty?
+      @@hash.empty?
+    end
+
+    def self.hash_get(key)
+      @@hash[key]
+    end
+
+    def self.hash_set(key, value)
+      @@hash[key] = value
+    end
+
+  end
+end

data/lib/object_cache/object_cache.rb

@@ -0,0 +1,69 @@
+
+class ObjectCache
+  @@ttl ||= 300
+  @@file_or_hash ||= nil
+  @@reader ||= nil
+  @@expires_at ||= nil
+  @@cache_store ||= ObjectCache::MemoryStore
+
+
+  def self.source(file_or_hash)
+    @@file_or_hash = file_or_hash
+  end
+
+  def self.expire_after(ttl)
+    @@ttl = ttl
+  end
+
+  def self.ttl
+    @@ttl
+  end
+
+  def self.cache_store
+    @@cache_store
+  end
+
+  def self.cache_store=(store)
+    @@cache_store = store
+  end
+
+  def self.refresh_the_cache
+    @@reader ||= Reader.new(@@file_or_hash)
+
+    groups = @@reader.grouped_objects
+    groups.each do |klass, ids|
+      #we need both ids and items to be in the same order for this to work
+      ids.sort!{|a,b| a.last <=> b.last}
+      items = constantize(klass).find(ids.collect(&:last))
+      items.sort!{|a,b| a.id <=> b.id}
+
+      @i = 0
+      items.each do |item|
+        cache_store.hash_set(ids[@i].first.to_s, item)
+        @i+=1
+      end
+      
+    end
+    @@expires_at = Time.now + (@@ttl || 300)
+  end
+
+  def self.constantize(camel_cased_word)
+    names = camel_cased_word.split('::')
+    names.shift if names.empty? || names.first.empty?
+
+    constant = Object
+    names.each do |name|
+      constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
+    end
+    constant
+  end
+
+  def self.method_missing(method_name)
+    if cache_store.hash_empty? || @@expires_at < Time.now
+      refresh_the_cache
+    end
+
+    cache_store.hash_get(method_name.to_s)
+  end
+
+end

data/lib/{object_reader.rb → object_cache/object_reader.rb}

@@ -1,4 +1,5 @@
 require 'yaml'
+require 'object_cache'
 
 class ObjectCache
   class Reader

data/lib/object_cache/rails_store.rb

@@ -0,0 +1,51 @@
+require "object_cache/cache_store"
+
+class ObjectCache
+  class RailsStore < ObjectCache::CacheStore
+    class << self
+
+      def fetch(klass, ids)
+        results = []
+        ids_to_refresh = []
+
+        [*ids].each do |id|
+          if Rails.cache.exist?(cache_key(klass, id))
+            results << get(klass, id)
+          else
+            ids_to_refresh << id
+          end
+        end
+
+        fresh_results = fetch_fresh_results(klass, ids_to_refresh)
+        results += fresh_results if fresh_results
+
+        array_or_value(results, ids)
+      end
+
+      def get(klass, id)
+        Rails.cache.read(cache_key(klass, id))
+      end
+
+      def set(klass, id, value)
+        Rails.cache.write(cache_key(klass, id), value, expires_at: ObjectCache.ttl)
+      end
+
+      def cache_key(klass, id)
+        "object_cache:#{klass}:#{id}"
+      end
+
+      def hash_get(key)
+        Rails.cache.read(hash_key(key))
+      end
+
+      def hash_set(key, value)
+        Rails.cache.write(hash_key(key), value, expires_at: ObjectCache.ttl)
+      end
+
+      def hash_key(key)
+        "object_cache:#{key}"
+      end
+
+    end
+  end
+end

data/lib/object_cache/version.rb

@@ -1,3 +1,3 @@
-module ObjectCache
-  VERSION = "0.0.3"
+class ObjectCache
+  VERSION = "0.0.4"
 end

data/lib/object_cache.rb

@@ -1,63 +1,4 @@
-require "object_reader"
-
-class ObjectCache
-  @@cache ||= {}
-  @@ttl ||= 60
-  @@file_or_hash ||= nil
-  @@reader ||= nil
-  @@expires_at ||= nil
-
-
-  def self.source(file_or_hash)
-    @@file_or_hash = file_or_hash
-  end
-
-  def self.expire_after(ttl)
-    @@ttl = ttl
-  end
-
-  def self.refresh_the_cache
-    @@reader ||= Reader.new(@@file_or_hash)
-    @@cache ||= {}
-
-    groups = @@reader.grouped_objects
-    groups.each do |klass, ids|
-      #we need both ids and items to be in the same order for this to work
-      ids.sort!{|a,b| a.last <=> b.last}
-      items = constantize(klass).find(ids.collect(&:last))
-      items.sort!{|a,b| a.id <=> b.id}
-
-      @i = 0
-      items.each do |item|
-        @@cache[ids[@i].first.to_s] = item
-        @i+=1
-      end
-      
-    end
-    @@expires_at = Time.now + (@@ttl || 5.minutes)
-  end
-
-  def self.constantize(camel_cased_word)
-    names = camel_cased_word.split('::')
-    names.shift if names.empty? || names.first.empty?
-
-    constant = Object
-    names.each do |name|
-      constant = constant.const_defined?(name) ? constant.const_get(name) : constant.const_missing(name)
-    end
-    constant
-  end
-
-  def self.hash
-    @@cache
-  end
-
-  def self.method_missing(method_name)
-    if @@cache.empty? || @@expires_at < Time.now
-      refresh_the_cache
-    end
-
-    @@cache[method_name.to_s]
-  end
-
-end
+require "object_cache/object_reader"
+require "object_cache/class_cacher"
+require "object_cache/memory_store"
+require "object_cache/object_cache"

data/object_cache.gemspec

@@ -17,4 +17,5 @@ Gem::Specification.new do |gem|
 
   gem.add_development_dependency(%q<rspec>, [">= 0"])
   gem.add_development_dependency(%q<rake>, ["~> 0.9.2"])
+  gem.add_development_dependency(%q<timecop>)
 end

data/spec/class_cacher_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+class Foo
+  def self.find(ids)
+    return ids
+  end
+end
+
+# we assume the cached objects have ids,
+# and for testing we use integers, so we shamelessly fake it :)
+class Integer
+  def id
+    self
+  end
+end
+
+describe ObjectCache::ClassCacher do
+  describe "calling of cache" do
+
+    it "should not perform a query after the object is cached" do
+      ObjectCache::ClassCacher.cache("Foo", 1)
+      Foo.should_not_receive(:find)
+      ObjectCache::ClassCacher.cache("Foo", 1).should == 1
+    end
+
+    it "should perform a query after ttl has passed" do
+      ObjectCache::ClassCacher.cache("Foo", 1)
+      Foo.should_receive(:find).with([1]).and_return([1])
+      Timecop.freeze(Time.now+30000) do
+        ObjectCache::ClassCacher.cache("Foo", 1).should == 1
+        Foo.should_not_receive(:find)
+        ObjectCache::ClassCacher.cache("Foo", 1)
+      end
+    end
+
+    it "should allow caching of multiple objects" do
+      ObjectCache::ClassCacher.cache("Foo", [1,2,3]).should == [1,2,3]
+    end
+
+    it "should allow caching of multiple objects" do
+      ObjectCache::ClassCacher.cache("Foo", [1,2,3])
+      Foo.should_not_receive(:find)
+
+      ObjectCache::ClassCacher.cache("Foo", [1,3]).should == [1,3]
+    end
+
+    it "should call the find method only for uncached objects" do
+      ObjectCache::ClassCacher.cache("Foo", [1,2,3])
+
+      Foo.should_receive(:find).with([4,5]).and_return([4,5])
+      ObjectCache::ClassCacher.cache("Foo", [1,3,4,5]).should == [1,3,4,5]
+
+      Foo.should_not_receive(:find)
+      ObjectCache::ClassCacher.cache("Foo", [1,2,3,4,5])
+    end
+
+  end
+end

data/spec/object_cache_spec.rb

@@ -47,6 +47,7 @@ describe ObjectCache do
 
       ObjectCache.foo.should == u1
     end
+
   end
 
 end

data/spec/spec_helper.rb

@@ -1,4 +1,5 @@
 require "object_cache"
+require "timecop"
   RSpec.configure do |config|
     # config.mock_with :mocha
     # config.mock_with :flexmock

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: object_cache
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.4
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-07-17 00:00:00.000000000Z
+date: 2012-07-20 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70189857627440 !ruby/object:Gem::Requirement
+  requirement: &70116759086560 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -21,10 +21,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70189857627440
+  version_requirements: *70116759086560
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70189857679980 !ruby/object:Gem::Requirement
+  requirement: &70116759086040 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,7 +32,18 @@ dependencies:
         version: 0.9.2
   type: :development
   prerelease: false
-  version_requirements: *70189857679980
+  version_requirements: *70116759086040
+- !ruby/object:Gem::Dependency
+  name: timecop
+  requirement: &70116759085660 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70116759085660
 description: simple object cache for ruby
 email:
 - tcaspy@gmail.com
@@ -48,9 +59,15 @@ files:
 - README.rdoc
 - Rakefile
 - lib/object_cache.rb
+- lib/object_cache/cache_store.rb
+- lib/object_cache/class_cacher.rb
+- lib/object_cache/memory_store.rb
+- lib/object_cache/object_cache.rb
+- lib/object_cache/object_reader.rb
+- lib/object_cache/rails_store.rb
 - lib/object_cache/version.rb
-- lib/object_reader.rb
 - object_cache.gemspec
+- spec/class_cacher_spec.rb
 - spec/fixtures/foo.yml
 - spec/object_cache_spec.rb
 - spec/spec_helper.rb
@@ -79,6 +96,7 @@ signing_key:
 specification_version: 3
 summary: hash table for object cache with defined TTL
 test_files:
+- spec/class_cacher_spec.rb
 - spec/fixtures/foo.yml
 - spec/object_cache_spec.rb
 - spec/spec_helper.rb