simple_cacheable 1.3.2 → 1.3.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b46d1110354d90d106fe5abdfed1eaa6801dd7e4
+  data.tar.gz: 763dac9a0c34135095974d09bb2575fbc5106ed2
+SHA512:
+  metadata.gz: f0fd40d41856c6efb7ecdfa1d8263ab2178b98c4cc8656d5bde2f3e67d71029c8cdebacf72a9d127abd775867d1d452fe86e8b122ec8f8adb315b9fab444999b
+  data.tar.gz: 322aad0ed21db8769cc06557df6461f8e8a29ddad18597922a4410480dc71a3d639217ea07a88b3c861db899802b4cf05c615242dc5069a9aab55325bfb0983a

data/.gitignore

@@ -1,5 +1,4 @@
 *.gem
 .bundle
-Gemfile.lock
 pkg/
 bin/

data/.ruby-gemset

@@ -0,0 +1 @@
+cacheable

data/.ruby-version

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

data/ChangeLog

@@ -0,0 +1,7 @@
+1.3.3
+* File Reorganization
+* Rails 4 Compatibility
+* Class Method Caching can accept arguments
+* Class Method Caching
+* has_one through association caching
+* has_and_belongs_to_many association caching

data/Gemfile

@@ -4,7 +4,7 @@ source "http://rubygems.org"
 gemspec
 
 platforms :ruby do
-  gem "sqlite3-ruby"
+  gem "sqlite3"
   gem "memcached"
 end
 
@@ -12,6 +12,4 @@ platforms :jruby do
   gem "activerecord-jdbc-adapter"
   gem "activerecord-jdbcsqlite3-adapter"
   gem "jruby-memcached"
-end
-
-gem "debugger"
+end

data/Gemfile.lock

@@ -0,0 +1,115 @@
+PATH
+  remote: .
+  specs:
+    simple_cacheable (1.3.2)
+      rails (>= 3.0.0)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    actionmailer (4.0.0)
+      actionpack (= 4.0.0)
+      mail (~> 2.5.3)
+    actionpack (4.0.0)
+      activesupport (= 4.0.0)
+      builder (~> 3.1.0)
+      erubis (~> 2.7.0)
+      rack (~> 1.5.2)
+      rack-test (~> 0.6.2)
+    activemodel (4.0.0)
+      activesupport (= 4.0.0)
+      builder (~> 3.1.0)
+    activerecord (4.0.0)
+      activemodel (= 4.0.0)
+      activerecord-deprecated_finders (~> 1.0.2)
+      activesupport (= 4.0.0)
+      arel (~> 4.0.0)
+    activerecord-deprecated_finders (1.0.3)
+    activerecord-jdbc-adapter (1.2.2.1)
+    activerecord-jdbcsqlite3-adapter (1.2.2.1)
+      activerecord-jdbc-adapter (~> 1.2.2.1)
+      jdbc-sqlite3 (~> 3.7.2)
+    activesupport (4.0.0)
+      i18n (~> 0.6, >= 0.6.4)
+      minitest (~> 4.2)
+      multi_json (~> 1.3)
+      thread_safe (~> 0.1)
+      tzinfo (~> 0.3.37)
+    arel (4.0.0)
+    atomic (1.1.10)
+    atomic (1.1.10-java)
+    builder (3.1.4)
+    diff-lcs (1.1.3)
+    erubis (2.7.0)
+    hike (1.2.3)
+    i18n (0.6.4)
+    jdbc-sqlite3 (3.7.2)
+    jruby-memcached (0.5.1)
+    mail (2.5.4)
+      mime-types (~> 1.16)
+      treetop (~> 1.4.8)
+    memcached (1.4.6)
+    metaclass (0.0.1)
+    mime-types (1.23)
+    minitest (4.7.5)
+    mocha (0.10.5)
+      metaclass (~> 0.0.1)
+    multi_json (1.7.7)
+    polyglot (0.3.3)
+    rack (1.5.2)
+    rack-test (0.6.2)
+      rack (>= 1.0)
+    rails (4.0.0)
+      actionmailer (= 4.0.0)
+      actionpack (= 4.0.0)
+      activerecord (= 4.0.0)
+      activesupport (= 4.0.0)
+      bundler (>= 1.3.0, < 2.0)
+      railties (= 4.0.0)
+      sprockets-rails (~> 2.0.0)
+    railties (4.0.0)
+      actionpack (= 4.0.0)
+      activesupport (= 4.0.0)
+      rake (>= 0.8.7)
+      thor (>= 0.18.1, < 2.0)
+    rake (10.1.0)
+    rspec (2.8.0)
+      rspec-core (~> 2.8.0)
+      rspec-expectations (~> 2.8.0)
+      rspec-mocks (~> 2.8.0)
+    rspec-core (2.8.0)
+    rspec-expectations (2.8.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.8.0)
+    sprockets (2.10.0)
+      hike (~> 1.2)
+      multi_json (~> 1.0)
+      rack (~> 1.0)
+      tilt (~> 1.1, != 1.3.0)
+    sprockets-rails (2.0.0)
+      actionpack (>= 3.0)
+      activesupport (>= 3.0)
+      sprockets (~> 2.8)
+    sqlite3 (1.3.7)
+    thor (0.18.1)
+    thread_safe (0.1.0)
+      atomic
+    tilt (1.4.1)
+    treetop (1.4.14)
+      polyglot
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.37)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  activerecord-jdbc-adapter
+  activerecord-jdbcsqlite3-adapter
+  jruby-memcached
+  memcached
+  mocha
+  rspec
+  simple_cacheable!
+  sqlite3

data/README.md

@@ -76,7 +76,7 @@ Gotchas
 
 Caching, and caching invalidation specifically, can be hard and confusing.  Simple Cacheable methods should
 expire correctly in most cases.  Be careful using `with_method` and `with_class_method`, they should
-specifically not be used to return collections.  This is demonstrated well Tobias Lutke's presentation: [Rockstar Memcaching][2].
+specifically not be used to return collections.  This is demonstrated well in Tobias Lutke's presentation: [Rockstar Memcaching][2].
 
 Copyright © 2011 Richard Huang (flyerhzm@gmail.com), released under the MIT license
 

data/lib/cacheable/caches.rb

@@ -0,0 +1,15 @@
+require "cacheable/types/key_cache"
+require "cacheable/types/attribute_cache"
+require "cacheable/types/method_cache"
+require "cacheable/types/class_method_cache"
+require "cacheable/types/association_cache"
+
+module Cacheable
+  module Caches
+    include Cacheable::KeyCache
+    include Cacheable::AttributeCache
+    include Cacheable::MethodCache
+    include Cacheable::ClassMethodCache
+    include Cacheable::AssocationCache
+  end
+end

data/lib/cacheable/expiry.rb

@@ -0,0 +1,53 @@
+module Cacheable
+  module Expiry
+    def expire_model_cache
+      expire_key_cache            if self.class.cached_key
+      expire_attribute_cache      if self.class.cached_indices.present?
+      expire_all_attribute_cache  if self.class.cached_indices.present?
+      expire_method_cache         if self.class.cached_methods.present?
+      expire_class_method_cache   if self.class.cached_class_methods.present?
+
+      if self.class.cached_associations.present?
+        self.class.cached_associations.each do |assoc|
+          expire_association_cache(assoc)
+        end
+      end
+    end
+
+    def expire_key_cache
+      Rails.cache.delete model_cache_key
+    end
+
+    def expire_attribute_cache
+      self.class.cached_indices.each do |attribute, values|
+        value = self.send(attribute)
+        Rails.cache.delete self.class.attribute_cache_key(attribute, value)
+      end
+    end
+
+    def expire_all_attribute_cache
+      self.class.cached_indices.each do |attribute, values|
+        value = self.send(attribute)
+        Rails.cache.delete self.class.all_attribute_cache_key(attribute, value)
+      end
+    end
+
+    def expire_method_cache
+      self.class.cached_methods.each do |meth|
+        Rails.cache.delete method_cache_key(meth)
+      end
+    end
+
+    def expire_class_method_cache
+      self.class.cached_class_methods.each do |meth, args|
+        args.each do |arg|
+          Rails.cache.delete self.class.class_method_cache_key(meth, arg)
+        end
+      end
+    end
+
+    def expire_association_cache(name)
+      Rails.cache.delete have_association_cache_key(name)
+    end
+  end
+end

data/lib/cacheable/keys.rb

@@ -0,0 +1,54 @@
+module Cacheable
+  module Keys
+
+    def self.included(base)
+      base.extend(Cacheable::Keys::ClassKeys)
+      base.send :include, Cacheable::Keys::InstanceKeys
+    end
+
+    module ClassKeys
+
+      def attribute_cache_key(attribute, value)
+        "#{name.tableize}/attribute/#{attribute}/#{URI.escape(value.to_s)}"
+      end
+
+      def all_attribute_cache_key(attribute, value)
+        "#{name.tableize}/attribute/#{attribute}/all/#{URI.escape(value.to_s)}"
+      end
+
+      def class_method_cache_key(meth, *args)
+        key = "#{name.tableize}/class_method/#{meth}"
+        args.flatten!
+        key += "/#{args.join('+')}" if args.any?
+        return key
+      end
+
+    end
+
+    module InstanceKeys
+
+      def model_cache_key
+        "#{self.class.name.tableize}/#{self.id.to_i}"
+      end
+
+      def method_cache_key(meth)
+        "#{model_cache_key}/method/#{meth}"
+      end
+
+      def belong_association_cache_key(name, polymorphic=nil)
+        name = name.to_s if name.is_a?(Symbol)
+        if polymorphic
+          "#{self.send("#{name}_type").tableize}/#{self.send("#{name}_id")}"
+        else
+          "#{name.tableize}/#{self.send(name + "_id")}"
+        end
+      end
+
+      def have_association_cache_key(name)
+        "#{model_cache_key}/association/#{name}"
+      end
+
+    end
+
+  end
+end

data/lib/cacheable/types/association_cache.rb

@@ -0,0 +1,92 @@
+module Cacheable
+  module AssocationCache
+
+    def with_association(*association_names)
+      self.cached_associations = association_names
+
+      association_names.each do |association_name|
+        association = reflect_on_association(association_name)
+
+        if :belongs_to == association.macro
+          polymorphic = association.options[:polymorphic]
+          polymorphic ||= false
+
+          define_method("cached_#{association_name}") do
+            Rails.cache.fetch belong_association_cache_key(association_name, polymorphic) do
+              send(association_name)
+            end
+          end
+        else
+          if through_reflection_name = association.options[:through]
+            through_association = self.reflect_on_association(through_reflection_name)
+
+            # FIXME it should be the only reflection but I'm not 100% positive
+            reverse_through_association = through_association.klass.reflect_on_all_associations(:belongs_to).first
+
+            # In a through association it doesn't have to be a belongs_to
+            reverse_association = association.klass.reflect_on_all_associations(:belongs_to).find { |reverse_association|
+              reverse_association.options[:polymorphic] ? reverse_association.name == association.source_reflection.options[:as] : reverse_association.klass == self
+            }
+            if reverse_association
+              association.klass.class_eval do
+                after_commit "expire_#{association_name}_cache".to_sym
+
+                define_method("expire_#{association_name}_cache") do
+                  if respond_to? "expire_#{reverse_association.name}_cache".to_sym
+                    # cached_viewable.expire_association_cache
+                    send("cached_#{reverse_association.name}").expire_association_cache(association_name)
+                  else
+                    send(reverse_association.name).send(reverse_through_association.name).expire_association_cache(association_name)
+                  end
+                end
+              end
+            end
+          elsif :has_and_belongs_to_many == association.macro
+              # No such thing as a polymorphic has_and_belongs_to_many
+              reverse_association = association.klass.reflect_on_all_associations(:has_and_belongs_to_many).find { |reverse_association|
+                reverse_association.klass == self
+              }
+
+              association.klass.class_eval do
+                after_commit "expire_#{association_name}_cache".to_sym
+
+                define_method "expire_#{association_name}_cache" do
+                  if respond_to? "cached_#{reverse_association.name}".to_sym
+                    # cached_viewable.expire_association_cache
+                    send("cached_#{reverse_association.name}").expire_association_cache(association_name)
+                  else
+                    send("#{reverse_association.name}").each do |assoc|
+                      assoc.expire_association_cache(association_name)
+                    end
+                  end
+                end
+              end
+          else
+            reverse_association = association.klass.reflect_on_all_associations(:belongs_to).find { |reverse_association|
+              reverse_association.options[:polymorphic] ? reverse_association.name == association.options[:as] : reverse_association.klass == self
+            }
+
+            association.klass.class_eval do
+              after_commit "expire_#{association_name}_cache".to_sym
+
+              define_method "expire_#{association_name}_cache" do
+                if respond_to? "cached_#{reverse_association.name}".to_sym
+                  send("cached_#{reverse_association.name}").expire_association_cache(association_name)
+                else
+                  send("#{reverse_association.name}").expire_association_cache(association_name)
+                end
+              end
+            end
+          end
+
+          define_method("cached_#{association_name}") do
+            Rails.cache.fetch have_association_cache_key(association_name) do
+              send(association_name).respond_to?(:to_a) ? send(association_name).to_a : send(association_name)
+            end
+          end
+        end
+      end
+    end
+
+  end
+end

data/lib/cacheable/types/attribute_cache.rb

@@ -0,0 +1,30 @@
+module Cacheable
+  module AttributeCache
+    def with_attribute(*attributes)
+      self.cached_indices = attributes.inject({}) { |indices, attribute| indices[attribute] = {} }
+
+      class_eval do
+        after_commit :expire_attribute_cache, :on => :update
+        after_commit :expire_all_attribute_cache, :on => :update
+      end
+
+      attributes.each do |attribute|
+        define_singleton_method("find_cached_by_#{attribute}") do |value|
+          self.cached_indices["#{attribute}"] ||= []
+          self.cached_indices["#{attribute}"] << value
+          Rails.cache.fetch attribute_cache_key("#{attribute}", value) 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
+          Rails.cache.fetch all_attribute_cache_key("#{attribute}", value) do
+            self.send("find_all_by_#{attribute}", value)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cacheable/types/class_method_cache.rb

@@ -0,0 +1,23 @@
+module Cacheable
+  module ClassMethodCache
+    # Cached class method
+    # Should expire on any instance save
+    def with_class_method(*methods)
+      self.cached_class_methods = methods.inject({}) { |indices, meth| indices[meth] = {} }
+
+      class_eval do
+        after_commit :expire_class_method_cache, on: :update
+      end
+
+      methods.each do |meth|
+        define_singleton_method("cached_#{meth}") do |*args|
+          self.cached_class_methods["#{meth}"] ||= []
+          self.cached_class_methods["#{meth}"] << args
+          Rails.cache.fetch class_method_cache_key(meth, args) do
+            self.method(meth).arity == 0 ? send(meth) : send(meth, *args)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cacheable/types/key_cache.rb

@@ -0,0 +1,17 @@
+module Cacheable
+  module KeyCache
+    def with_key
+      self.cached_key = true
+
+      class_eval do
+        after_commit :expire_key_cache, on: :update
+      end
+
+      define_singleton_method("find_cached") do |id|
+        Rails.cache.fetch "#{name.tableize}/" + id.to_i.to_s do
+          self.find(id)
+        end
+      end
+    end
+  end
+end

data/lib/cacheable/types/method_cache.rb

@@ -0,0 +1,19 @@
+module Cacheable
+  module MethodCache
+    def with_method(*methods)
+      self.cached_methods = methods
+
+      class_eval do
+        after_commit :expire_method_cache, :on => :update
+      end
+
+      methods.each do |meth|
+        define_method("cached_#{meth}") do
+          Rails.cache.fetch method_cache_key(meth) do
+            send(meth)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cacheable/version.rb

@@ -1,3 +1,3 @@
 module Cacheable
-  VERSION = "1.3.2"
+  VERSION = "1.3.3"
 end