generation_cacheable 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: add01c39075f3847dfc1e750ece37f1329de16f5
+  data.tar.gz: 2f5c3410a8f11824e9d77a774ea5f57ef849b4e5
+SHA512:
+  metadata.gz: 0ba9aade08e246c5a995c00636f2ea483533b043ade43b1e6739430951c291d723d540939bfa37ee8fd8d13288d6022ed29f7ad9009debd05c14439a775bc008
+  data.tar.gz: 8d975869ee3d4922c3c9557d08dc453bc14b7f195ba6f13b08062d80d3ecc2b666ca5e44a8f5789d23a3027b165ef229355d0176c9d76cdf516cb268569115fe

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+pkg/
+bin/

data/.rspec

@@ -0,0 +1,2 @@
+--format nested
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+generation_cacheable

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.0.0

data/ChangeLog

@@ -0,0 +1,2 @@
+0.0.1
+* Initial implementation

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in cacheable.gemspec
+gemspec
+
+platforms :ruby do
+  gem "sqlite3"
+  gem "memcached"
+  gem "cityhash"
+end
+
+platforms :jruby do
+  gem "activerecord-jdbc-adapter"
+  gem "activerecord-jdbcsqlite3-adapter"
+  gem "jruby-memcached"
+end

data/README.md

@@ -0,0 +1,33 @@
+Generation Cacheable
+====================
+
+A rails cache implementation that began as a fork of [simple cacheable](https://github.com/flyerhzm/simple_cacheable) and incorporated some ideas from [identity cache](https://github.com/Shopify/identity_cache) as well. 
+
+Usage
+=====
+
+```ruby
+class User < ActiveRecord::Base
+  include GenCache
+
+  has_one :profile
+  has_many :friends
+
+  model_cache do
+    with_key                             # => User.find_cached(1)
+    with_attribute :name                 # => User.find_cached_by_name("Pathouse")
+    with_method :meaning_of_life         # => User.cached_meaning_of_life
+    with_class_method :population        # => User.cached_population
+    with_association :profile, :friends  # => User.cached_profile  User.cached_friends
+  end
+
+  def self.population
+    all.count
+  end
+
+  def meaning_of_life
+    42
+  end
+end
+```
+

data/Rakefile

@@ -0,0 +1,8 @@
+#!/usr/bin/env rake
+require "bundler/gem_tasks"
+
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/generation_cacheable.gemspec

@@ -0,0 +1,23 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "gen_cache/version"
+
+Gem::Specification.new do |s|
+  s.name        = "generation_cacheable"
+  s.version     = GenerationCacheable::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Pat McGee"]
+  s.email       = ["patmcgee331@gmail.com"]
+  s.homepage    = "https://github.com/pathouse/generation-cacheable"
+  s.summary     = %q{a simple cache implementation with attribute based expiry}
+  s.description = %q{a simple cache implementation with attribute based expiry}
+
+  s.add_dependency("rails", ">= 3.0.0")
+  s.add_development_dependency("rspec", "2.8")
+  s.add_development_dependency("mocha", "0.10.5")
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/gen_cache.rb

@@ -0,0 +1,32 @@
+require 'uri'
+require 'cityhash'
+require "gen_cache/caches"
+require "gen_cache/keys"
+require "gen_cache/expiry"
+require "gen_cache/cache_io/fetching"
+require "gen_cache/cache_io/formatting"
+require "gen_cache/cache_io/parsing"
+
+module GenCache
+
+  def self.included(base)
+    base.extend(GenCache::Caches)
+    base.extend(GenCache::ClassMethods)
+
+    base.class_eval do
+      class_attribute   :cached_key,
+                        :cached_indices,
+                        :cached_methods,
+                        :cached_class_methods,
+                        :cached_associations
+      after_commit :expire_all
+    end
+  end
+
+  module ClassMethods
+    def model_cache(&block)
+      instance_exec &block
+    end
+  end
+
+end

data/lib/gen_cache/cache_io/fetching.rb

@@ -0,0 +1,78 @@
+module GenCache
+
+	def self.fetch(key_blob, options={}, &block)
+		unless key_blob.is_a?(Array)
+			single_fetch(key_blob, options) { yield if block_given? }
+		else
+			multiple_fetch(key_blob) { yield if block_given? }
+		end
+	end
+
+	def self.single_fetch(key_blob, options, &block)
+		result = read_from_cache(key_blob)
+		method_args = symbolize_args(options[:args])
+		should_write = false
+
+		if block_given?
+			if method_args != :no_args && (result.nil? || result[method_args].nil?)
+				result ||= {}
+				result[method_args] = yield
+				should_write = true
+			elsif method_args == :no_args && result.nil?
+				result = yield
+				should_write = true
+			end
+		end
+
+		write_to_cache(key_blob, result) if should_write
+		
+		result = (method_args == :no_args) ? result : result[method_args]
+	end
+
+	def self.multiple_fetch(key_blobs, &block)
+		results = read_multi_from_cache(key_blobs)
+		if results.nil?
+			if block_given?
+				results = yield
+				write_multi_to_cache(results)
+			end
+		end
+		results.values
+	end
+
+	##
+	## READING FROM THE CACHE
+	##
+
+	def self.read_from_cache(key_blob)
+		result = Rails.cache.read key_blob[:key]
+		return result if result.nil?
+		parse_with_key(result, key_blob[:type])
+	end
+
+	def self.read_multi_from_cache(key_blobs)
+		keys = key_blobs.map { |blob| blob[:key] }
+		results = Rails.cache.read_multi(*keys)
+		return nil if results.values.all?(&:nil?)
+		results.each do |key, value|
+			type = key_blobs.select {|kb| kb.has_value?(key) }.first[:type]
+			results[key] = parse_with_key(value, type)
+		end
+		results
+	end
+
+	###
+	### WRITING TO THE CACHE
+	###
+
+	def self.write_multi_to_cache(keys_and_results)
+		keys_and_results.each do |key, result|
+			write_to_cache(key, result)
+		end
+	end
+
+	def self.write_to_cache(key_blob, result)
+		formatted_result = format_with_key(result, key_blob[:type])
+		Rails.cache.write key_blob[:key], formatted_result
+	end
+end

data/lib/gen_cache/cache_io/formatting.rb

@@ -0,0 +1,75 @@
+module GenCache
+
+	def self.format_with_key(result, key_type)
+		return if result.nil?
+		if key_type == :association
+			result
+		elsif key_type == :object
+			formatted_result = format_object(result)
+		else
+			formatted_result = format_method(result)
+		end
+	end 
+
+	## OBJECT FORMATTING ##
+
+	def self.format_object(object)
+		if object.is_a?(Array)
+			object.map { |obj| coder_from_record(obj) }
+		else
+			coder_from_record(object)
+		end
+	end
+
+	def self.coder_from_record(record)
+		unless record.nil?
+			coder = { :class => record.class }
+			record.encode_with(coder)
+			coder
+		end
+	end
+
+	## METHOD FORMATTING ##
+	def self.symbolize_args(args)
+		return :no_args if args.nil? || args.empty?
+		args.map do |arg|
+			if arg.is_a?(Hash)
+				arg.map {|k,v| "#{k}:#{v}"}.join(",")
+			elsif arg.is_a?(Array)
+				arg.join(",")
+			else
+				arg.to_s.split(" ").join("_")
+			end
+		end.join("+").to_sym
+	end
+
+	def self.escape_punctuation(string)
+		string.sub(/\?\Z/, '_query').sub(/!\Z/, '_bang')
+	end
+
+	def self.detect_object(data)
+		data.is_a?(ActiveRecord::Base) || 
+		(data.is_a?(Array) && data[0].is_a?(ActiveRecord::Base))
+	end
+
+	def self.format_method(result)
+		if detect_object(result)
+			format_object(result)
+		elsif result.is_a?(Hash)
+			result.each do |arg_key, value|
+				result[arg_key] = format_data(value)
+			end
+		else
+			format_data(result)
+		end
+	end
+
+	def self.format_data(result)
+		if detect_object(result)
+			format_object(result)
+		else
+			result
+		end
+	end
+
+end

data/lib/gen_cache/cache_io/parsing.rb

@@ -0,0 +1,66 @@
+module GenCache
+
+	def self.parse_with_key(result, key_type)
+		return if result.nil?
+		if key_type == :association
+			result
+		elsif key_type == :object
+			object_parse(result)
+		else
+			method_parse(result)
+		end
+	end
+
+	## OBJECT PARSING ##
+
+	def self.object_parse(result)
+		if result.is_a?(Array)
+			result.map {|obj| record_from_coder(obj)}
+		else
+			record_from_coder(result)
+		end
+	end
+
+	def self.record_from_coder(coder)
+		record = coder[:class].allocate
+		record.init_with(coder)
+		record
+	end
+
+	## METHOD PARSING ## 
+	#
+	## METHOD STORE FORMATTING
+	#
+	# { args.to_string.to_symbol => answer }
+
+	def self.detect_coder(data)
+		(data.is_a?(Hash) && hash_inspect(data)) ||
+		(data.is_a?(Array) && data[0].is_a?(Hash) && hash_inspect(data[0]))
+	end
+
+	def self.hash_inspect(hash)
+		hash.has_key?(:class) && hash.has_key?('attributes')
+	end
+
+	def self.method_parse(result)
+		if detect_coder(result)
+			object_parse(result)
+		elsif result.is_a?(Hash)
+			result.each do |k,v|
+				result[k] = data_parse(v)
+			end
+		else
+			data_parse(result)
+		end
+	end
+
+	## DATA PARSING ##
+
+	def self.data_parse(result)
+		if detect_coder(result)
+			object_parse(result)
+		else
+			result
+		end
+	end
+end

data/lib/gen_cache/cache_types/association_cache.rb

@@ -0,0 +1,50 @@
+module GenCache
+  module AssocationCache
+
+    def with_association(*association_names)
+      self.cached_associations ||= []
+      self.cached_associations += association_names
+
+      association_names.each do |assoc_name|
+        cached_assoc_methods(assoc_name)
+      end
+    end
+
+    def cached_assoc_methods(name)
+      method_name = "cached_#{name}"
+      define_method(method_name) do
+        cache_key = GenCache.association_key(self, name)
+        
+        # an object's association cache holds a collection of the instance keys
+        # for the objects returned by a call to that association. These are read first
+        if instance_variable_get("@#{method_name}").nil?
+          instance_keys = GenCache.fetch(cache_key) do
+            Array.wrap(self.send(name)).map { |obj| GenCache.instance_key(obj.class, obj.id) }
+          end
+          
+          # all of the instance keys are read in a single multi_read
+          association = GenCache.fetch(instance_keys) do |key_blobs|
+            result = {}
+            instance_keys.each do |ik|
+              key_parts = ik[:key].scan(/(^.*)\/(.*)\/(.*$)/).flatten
+              result[ik] = Object.const_get(key_parts.first.singularize.capitalize).send(:find, key_parts.last.to_i)
+            end
+            result
+          end
+
+          # plural associations expect arrays, singular associations expect single objects
+          association = if association.size == 0 
+                          name.to_s.pluralize == name.to_s ? [] : nil
+                        elsif association.size == 1
+                          name.to_s.pluralize == name.to_s ? association : association.first
+                        else
+                          association
+                        end
+
+          instance_variable_set("@#{method_name}", association)
+        end
+        instance_variable_get("@#{method_name}")
+      end
+    end
+  end
+end

data/lib/gen_cache/cache_types/attribute_cache.rb

@@ -0,0 +1,30 @@
+module GenCache
+  module AttributeCache
+    def with_attribute(*attributes)
+      self.cached_indices ||= {}
+      self.cached_indices = self.cached_indices.merge(attributes.each_with_object({}) {
+        |attribute, indices| indices[attribute] = {}
+      })
+
+      attributes.each do |attribute|
+        define_singleton_method("find_cached_by_#{attribute}") do |value|
+          self.cached_indices["#{attribute}"] ||= []
+          self.cached_indices["#{attribute}"] << value
+          cache_key = GenCache.attribute_key(self, attribute, value)
+          GenCache.fetch(cache_key) do
+            self.send("find_by_#{attribute}", value)
+          end
+        end
+
+        define_singleton_method("find_cached_all_by_#{attribute}") do |value|
+          self.cached_indices["#{attribute}"] ||= []
+          self.cached_indices["#{attribute}"] << value
+          cache_key = GenCache.attribute_key(self, attribute, value, all: true)
+          GenCache.fetch(cache_key) do
+            self.send("find_all_by_#{attribute}", value)
+          end
+        end
+      end
+    end
+  end
+end