object_cacheable 1.0.0

data/Gemfile

@@ -0,0 +1,9 @@
+source "http://www.rubygems.org"
+
+gem 'minitest'
+gem 'minitest-metadata'
+gem 'minitest-reporters'
+gem 'minitest-spec-context'
+gem 'mocha'
+gem 'spork'
+gem 'spork-minitest'

data/lib/cache_configs.yml

@@ -0,0 +1,11 @@
+production:
+  cache: 'Rails.cache'
+  logger: 'Rails.logger'
+  
+development:
+  cache: 'Rails.cache'
+  logger: 'Rails.logger'
+  
+test:
+  cache: 'Cacheable::Utils.test_cache'
+  logger: 'Cacheable::Utils.test_logger'

data/lib/cache_configuration.rb

@@ -0,0 +1,41 @@
+require 'yaml'
+require "#{File.dirname(__FILE__)}/cache_utils"
+
+module Cacheable
+  def self.cache
+    CacheConfiguration.cache
+  end
+  
+  def self.logger
+    CacheConfiguration.logger
+  end
+  
+  class CacheConfiguration
+    @@cache_instance = nil
+    @@logger_instance = nil
+    
+    def self.load_config
+      configs = YAML.load_file("#{File.dirname(__FILE__)}/cache_configs.yml")
+      env = environment
+      
+      @@cache_instance  = eval(configs[env]['cache'])
+      @@logger_instance = eval(configs[env]['logger'])
+    end
+    
+    def self.environment
+      Rails.env
+    rescue => error
+      'test'
+    end
+    
+    def self.cache
+      load_config if @@cache_instance.nil?
+      @@cache_instance
+    end
+    
+    def self.logger
+      load_config if @@logger_instance.nil?
+      @@logger_instance
+    end
+  end
+end

data/lib/cache_utils.rb

@@ -0,0 +1,52 @@
+module Cacheable
+  class Utils
+    def self.test_cache
+      Cacheable::TestCache.instance
+    end
+    
+    def self.test_logger
+      Cacheable::TestLogger.instance  
+    end
+  end
+  
+  class TestCache
+    @@cache_storage = {}
+    @@cache_instance = nil
+    
+    def self.instance
+      @@cache_instance ||= TestCache.new
+    end
+    
+    def fetch(key)
+      @@cache_storage[key]
+    end
+    
+    def write(key, value, options = {})
+      @@cache_storage[key] = value
+    end
+    
+    def delete(key)
+      @@cache_storage.delete(key)
+    end
+    
+    def keys
+      @@cache_storage.keys
+    end
+  end
+  
+  class TestLogger
+    @@logger_instance = nil
+    
+    def self.instance
+      @@logger_instance ||= TestLogger.new
+    end
+    
+    def info(message)
+      puts message
+    end
+    
+    alias_method :warning, :info
+    alias_method :error, :info
+    
+  end
+end

data/lib/cacheable.rb

@@ -0,0 +1,154 @@
+require "#{File.dirname(__FILE__)}/cache_configuration"
+
+module Cacheable
+  
+  def self.included(base)
+    base.class_eval do
+
+      def self.method_missing(name, *args, &block)
+        query_attributes = []
+
+        if name.to_s.start_with? 'fetch_by_'
+          # puts("\n\nname = #{name}\nname['fetch_by_'.length, name.length] = #{name['fetch_by_'.length, name.length]}")
+
+          query_attributes = name['fetch_by_'.length, name.length].split('_and_')
+          return nil if query_attributes == []
+
+          # puts("\n\n Cacheable method_missing - query attributes = #{query_attributes}, arguments = #{args.inspect}\n\n")
+
+          find_in_cache(query_attributes,args) or refresh_cache(query_attributes, args)
+        else
+          super
+        end
+
+      end
+
+      # Use this method if you want to explicitly re-fetch the whole object with given attributes-values, and write the newly fetched object to the cache
+      def self.refresh_cache(attributes, args)
+
+        obj = fetch(attributes, args)
+        return nil if obj.nil?
+
+        obj.cached_by_attributes = attributes
+        return obj.update_cache
+
+        rescue => error
+          Cacheable::logger.error("\n\nError in Cacheable.refresh_cache error = #{error.message}\n#{error.backtrace.join("\n")}\n\n")
+          return nil
+      end
+
+      # This method must be implemented by subclasses, because only subclasses know how to do the actual data fetch
+      def self.fetch(attributes,args)
+        raise 'The method <fetch> must be implemented by subclass'
+      end
+
+      # including classes that want to have time-based expire can implement this method
+      # can be 5.minutes, 1.day ...etc...
+      # 0 is never expire
+      def self.cache_expired_duration
+        600 # default to 10 minutes
+      end
+
+      private
+      def self.find_in_cache(attributes,args)
+        cache_key = build_cache_key(attributes,args)
+
+        obj = Cacheable::cache.fetch(cache_key)
+        if cache_expired_duration > 0
+          cached_time = Cacheable::cache.fetch(build_cached_time_key(attributes,args)) || 0
+          return refresh_cache(attributes, args) if ( (Time.now.to_i - cached_time > cache_expired_duration) && obj)
+        end
+
+        obj
+      end
+
+      def self.save_to_cache(attributes, args, obj)
+        cache_key = build_cache_key(attributes,args)
+        options = {}
+
+        if cache_expired_duration > 0
+          options = { expires_in: cache_expired_duration.to_i }
+          Cacheable::cache.write(build_cached_time_key(attributes,args), Time.now.to_i)
+        end
+
+        Cacheable::cache.write(cache_key, obj, options)
+      end
+
+      def self.build_cache_key(attributes,args)
+        "#{self.name}_#{attributes.join('_')}_#{args.map(&:to_s).join('_')}"
+      end
+
+      # store the time when the object is cached
+      def self.build_cached_time_key(attributes,args)
+        "#{build_cache_key(attributes,args)}_cached_time"
+      end
+
+    end
+  end # End of class methods
+
+  # Instance methods
+
+  # Delete cached object from cache
+  # For example if you have a cached current_profile, and you want to delete it out of cache use current_profile.delete_from_cache
+  def delete_from_cache
+    cached_key_attributes = cached_by_attributes
+    raise "This object has never been cached in the cache #{self.inspect}" if cached_key_attributes.nil?
+
+    cached_key_attributes.each do |attribute_keys|
+      attribute_values = build_attribute_values(attribute_keys)
+      cache_key = self.class.build_cache_key(attribute_keys,attribute_values)
+      Cacheable::cache.delete(cache_key)
+    end
+
+    self
+  end
+
+  # This method updates all instances of an object with all cached keys (cached by different attributes)
+  # If you have an instance of a cached object, you just modify it or partially modify it, and want to write it back to the cache
+  # then use this method. For example if you have a current_profile, and its info changed, use current_profile.update_cache
+  def update_cache
+    cached_key_attributes = cached_by_attributes
+    raise "This object has never been cached in the cache #{self.inspect}" if cached_key_attributes.nil?
+
+    cached_key_attributes.each do |attribute_keys|
+      attribute_values = build_attribute_values(attribute_keys)
+      self.class.save_to_cache(attribute_keys, attribute_values, self)
+    end
+
+    self
+
+  end
+  
+
+  # All the attributes that instances of classes are cached by are dynamically created and store in cache
+  # in order to support multiple runtimes of cache server
+  def cached_by_attributes=(attributes)
+    all_attributes = all_cached_by_attributes
+    cached_attributes_for_class = all_attributes[self.class.name] || []
+
+    cached_attributes_for_class << attributes if !cached_attributes_for_class.include?(attributes)
+
+    all_attributes[self.class.name] = cached_attributes_for_class
+    Cacheable::cache.write('all_cached_by_attributes', all_attributes)
+  end
+
+  private
+  def cached_by_attributes
+    all_cached_by_attributes[self.class.name]
+  end
+
+  def all_cached_by_attributes
+    Cacheable::cache.fetch('all_cached_by_attributes') || {}
+  end
+  
+  def build_attribute_values(attribute_keys)
+    attribute_values = []
+
+    attribute_keys.each do |attribute|
+      attribute_values << self.send(attribute)
+    end
+
+    attribute_values
+  end
+
+end

data/object_cacheable.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |s|
+  s.name        = 'object_cacheable'
+  s.version     = '1.0.0'
+  s.summary     = "Object-level caching"
+  s.description = "A gem for object-level caching."
+  s.authors     = ['Linh Chau']
+  s.email       = 'chauhonglinh@gmail.com'
+  s.files       = [
+                    './Gemfile', './object_cacheable.gemspec', 
+                    'lib/cache_configs.yml', 'lib/cache_configuration.rb', 'lib/cache_utils.rb', 'lib/cacheable.rb',
+                    'test/models/cacheable_test.rb'
+                  ]
+  s.homepage    = 'https://github.com/linhchauatl/object_cacheable.git'
+end

data/test/models/cacheable_test.rb

@@ -0,0 +1,191 @@
+# Run test from the command line, gem root
+# bundle exec ruby -Ilib test/models/cacheable_test.rb 
+
+require 'minitest/autorun'
+require 'minitest-spec-context'
+require 'cacheable'
+require 'mocha'
+
+class TestCacheable
+  include Cacheable
+  attr_accessor :id, :value_1, :value_2, :value_3
+
+  # This method mimics a real call to database or webservices
+  def self.fetch(attributes, args)
+    # Assume that the combination of (value_1 + value_2) will uniquely identify one instance - for testing purpose
+    # For testing convenience, this implementation returns the same value object for the following calls:
+    # obj1 = TestCacheable.fetch_by_id(1)
+    # obj2 = TestCacheable.fetch_by_value_1_and_value_2('value 1', 'value 2')
+
+    # The calls with different ids will return different objects
+
+    if ( (args.size == 1) or (args.size == 3) )
+      return TestCacheable.new(*args)
+    elsif (args.size == 2)
+      # Because the initilize always expects value 1 before value 2, so if we have attributes sent as ['value_2', 'value_1'], we have to reverse the args
+      created_args = (attributes == ['value_1', 'value_2'])? args : args.reverse
+      
+      return (args.sort == ['value 1', 'value 2'])? TestCacheable.new(1, *created_args) : TestCacheable.new( (args[0].to_s.hash + args[1].to_s.hash), *created_args)
+    end
+
+    return TestCacheable.new(100, 'test value 1', 'test value 2')
+
+  end
+
+  def initialize(an_id, a_value_1 = 'value 1', a_value_2 = 'value 2')
+    self.id = an_id
+
+    self.value_1 = a_value_1
+    self.value_2 = a_value_2 
+
+
+    self.value_3 = 'Original Value 3'
+  end
+
+  def ==(obj)
+    self.id == obj.id && self.value_1 == obj.value_1 && self.value_2 == obj.value_2 && self.value_3 == obj.value_3
+  end
+
+end
+
+
+describe Cacheable do
+
+  context 'fetch object' do
+    it 'calls the real fetch when the object is not in cache, then puts object in the cache' do
+
+      # First, make sure that there is nothing in cache
+      cached_obj = Cacheable::cache.fetch('TestCacheable_id_1')
+      cached_obj.must_be_nil
+
+      # Call the method that fetches the object and puts in cache
+      obj = TestCacheable.fetch_by_id(1)
+      obj.wont_be_nil
+
+      cached_obj = Cacheable::cache.fetch('TestCacheable_id_1')
+      cached_obj.must_equal obj
+
+      # Make sure that it doesn't make a real call to fetch the second time
+      TestCacheable.stubs(:fetch).returns(nil) # If this gets called, the result_obj will be nil
+      result_obj = TestCacheable.fetch_by_id(1)
+      result_obj.must_equal obj
+
+      # clean the cache after finish
+      obj.delete_from_cache
+    end
+
+    it 'fetches and caches different objects separately' do
+      obj3 = TestCacheable.fetch_by_id(3)
+      obj3.wont_be_nil
+
+      obj4 = TestCacheable.fetch_by_id(4)
+      obj4.wont_be_nil
+
+      # Fetched objects must be different
+      obj3.wont_equal obj4
+
+      #Cached objects must be different
+      cached_obj3 = Cacheable::cache.fetch('TestCacheable_id_3')
+      cached_obj3.must_equal obj3
+
+      cached_obj4 = Cacheable::cache.fetch('TestCacheable_id_4')
+      cached_obj4.must_equal obj4
+
+      cached_obj3.wont_equal cached_obj4
+
+      # clean the cache after finish
+      obj3.delete_from_cache
+      obj4.delete_from_cache
+    end
+
+    it 'fetches the same object with different ordered combinations of keys' do
+      obj1 = TestCacheable.fetch_by_value_1_and_value_2('key 1', 'key 2')
+      obj2 = TestCacheable.fetch_by_value_2_and_value_1('key 2', 'key 1')
+
+      obj1.must_equal obj2
+
+      cached_obj1 = Cacheable::cache.fetch('TestCacheable_value_1_value_2_key 1_key 2')
+      cached_obj2 = Cacheable::cache.fetch('TestCacheable_value_2_value_1_key 2_key 1')
+
+      cached_obj1.must_equal cached_obj2
+
+      # clean the cache after finish - make sure that obj1 and obj2 are both deleted from cache
+      obj1.delete_from_cache
+      cached_obj2 = Cacheable::cache.fetch('TestCacheable_value_2_value_1_key 2_key 1')
+      cached_obj2.must_be_nil
+
+    end
+
+    it 'fetches two different objects with revert values for keys' do
+      # These 2 different objects have revert values for keys, 
+      # for example [firstname, lastname] = [John, Smith] and [fistname, lastname] = [Smith, John]
+      # Unlikely to happen, but we will test anyway
+      obj1 = TestCacheable.fetch_by_value_1_and_value_2('value 1234', 'value 5678')
+      obj2 = TestCacheable.fetch_by_value_1_and_value_2('value 5678', 'value 1234')
+
+      # fetched objects are different
+      obj1.wont_equal obj2
+
+      cached_obj1 = Cacheable::cache.fetch('TestCacheable_value_1_value_2_value 1234_value 5678')
+      cached_obj1.must_equal obj1
+
+      cached_obj2 = Cacheable::cache.fetch('TestCacheable_value_1_value_2_value 5678_value 1234')
+      cached_obj2.must_equal obj2
+
+      # cached objects are different
+      cached_obj1.wont_equal cached_obj2
+
+       # clean the cache after finish
+      obj1.delete_from_cache
+      obj2.delete_from_cache
+    end
+
+  end
+
+  context 'update object' do
+    it 'updates all instances of object in the cache' do
+      obj1 = TestCacheable.fetch_by_id(1)
+      obj2 = TestCacheable.fetch_by_value_1_and_value_2('value 1', 'value 2')
+
+      # We expect that obj1 and obj2 are 2 cached instances of the same object:
+      obj1.must_equal obj2
+
+      # Now update obj1 and expect the value is changed in the cache
+      obj1.value_3 = 'New value 3'
+      obj1.update_cache
+
+      cached_obj1 = Cacheable::cache.fetch('TestCacheable_id_1')
+      cached_obj1.value_3.must_equal 'New value 3'
+
+      # We also expect that the obj_2 value_3 is also changed
+      cached_obj2 = Cacheable::cache.fetch('TestCacheable_value_1_value_2_value 1_value 2')
+      cached_obj2.value_3.must_equal 'New value 3'
+
+       # clean the cache after finish
+      obj1.delete_from_cache
+      
+    end
+  end
+
+  context 'delete object' do
+    it 'deletes all instances of object in the cache' do
+      obj1 = TestCacheable.fetch_by_id(1)
+      obj2 = TestCacheable.fetch_by_value_1_and_value_2('value 1', 'value 2')
+
+      # We expect that obj1 and obj2 are 2 cached instances of the same object:
+      obj1.must_equal obj2
+
+      # Delete obj1
+      obj1.delete_from_cache
+
+      cached_obj1 = Cacheable::cache.fetch('TestCacheable_id_1')
+      cached_obj1.must_be_nil
+
+      # The obj2 in the cache now must be nil too
+      cached_obj2 = Cacheable::cache.fetch('TestCacheable_value_1_value_2_value 1_value 2')
+      cached_obj2.must_be_nil
+
+    end
+  end
+
+end

metadata

@@ -0,0 +1,68 @@
+--- !ruby/object:Gem::Specification 
+name: object_cacheable
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 1
+  - 0
+  - 0
+  version: 1.0.0
+platform: ruby
+authors: 
+- Linh Chau
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2013-03-28 00:00:00 -05:00
+default_executable: 
+dependencies: []
+
+description: A gem for object-level caching.
+email: chauhonglinh@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- ./Gemfile
+- ./object_cacheable.gemspec
+- lib/cache_configs.yml
+- lib/cache_configuration.rb
+- lib/cache_utils.rb
+- lib/cacheable.rb
+- test/models/cacheable_test.rb
+has_rdoc: true
+homepage: https://github.com/linhchauatl/object_cacheable.git
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Object-level caching
+test_files: []
+