rails-cache-tags 1.2.0 → 1.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1fec05417aaeacefe45090371a1987e97811b4a5
+  data.tar.gz: 80ab586b1cece89e8463d5306a5f072dcae869bd
+SHA512:
+  metadata.gz: 4c4926e08c481634ad5d0307b671fd3103258876c9ab51533364313f79c4ed27ff950396493bb140f7a4905341b0fd7161ddb93a99ae9116ad0c17a2dafbb03b
+  data.tar.gz: 2663ab5400dde3728d4cf4187c2190910be91babbde55070fdab636b319fa1429b60ba78dce8e51bb26d32ab3c6f4a5f9b77e35811ddd45d9a5d8ed800d5aa49

data/lib/rails-cache-tags.rb

@@ -1,42 +1,43 @@
-require "active_support/cache"
+require 'active_support'
+require 'active_support/cache'
 
-require "action_controller"
+require 'rails/cache/tags/store'
 
-require "rails/cache/tag"
-require "rails/cache/tags/store"
-
-# Patch ActiveSupport common store
 module ActiveSupport
   module Cache
-    class Store
-      extend Rails::Cache::Tags::Store
-    end
-
     class Entry
       attr_accessor :tags
     end
+
+    # patch built-in stores
+    [:FileStore, :MemCacheStore, :MemoryStore].each do |const|
+      if const_defined?(const)
+        begin
+          const_get(const).send(:include, Rails::Cache::Tags::Store)
+        rescue LoadError, NameError
+          # ignore
+        end
+      end
+    end
   end
 end
 
-# Patch ActionDispatch
-class ActionController::Base < ActionController::Metal
-  def expire_fragments_by_tags *args
-    return unless cache_configured?
+# Patch ActionController
+ActiveSupport.on_load(:action_controller) do
+  require 'rails/cache/tags/action_controller'
 
-    cache_store.delete_tag *args
-  end
-  alias expire_fragments_by_tag expire_fragments_by_tags
+  ActionController::Base.send(:include, Rails::Cache::Tags::ActionController)
 end
 
 # Patch Dalli store
 begin
-  require "dalli"
-  require "dalli/version"
+  require 'dalli'
+  require 'dalli/version'
 
   if Dalli::VERSION.to_f > 2
-    require "active_support/cache/dalli_store"
+    require 'active_support/cache/dalli_store'
 
-    ActiveSupport::Cache::DalliStore.extend(Rails::Cache::Tags::Store)
+    ActiveSupport::Cache::DalliStore.send(:include, Rails::Cache::Tags::Store)
   end
 rescue LoadError, NameError
   # ignore

data/lib/rails/cache/tags/action_controller.rb

@@ -0,0 +1,14 @@
+module Rails
+  module Cache
+    module Tags
+      module ActionController
+        def expire_fragments_by_tags(*args)
+          return unless cache_configured?
+
+          cache_store.delete_tag(*args)
+        end
+        alias_method :expire_fragments_by_tag, :expire_fragments_by_tags
+      end
+    end
+  end
+end

data/lib/rails/cache/tags/set.rb

@@ -0,0 +1,47 @@
+# coding: utf-8
+
+require 'rails/cache/tags/tag'
+
+module Rails
+  module Cache
+    module Tags
+      class Set
+        KEY_PREFIX = '_tags'
+
+        # @param [ActiveSupport::Cache::Store] cache
+        def initialize(cache)
+          @cache = cache
+        end
+
+        def current(tag)
+          @cache.fetch_without_tags(tag.to_key) { 1 }.to_i
+        end
+
+        def expire(tag)
+          version = current(tag) + 1
+
+          @cache.write_without_tags(tag.to_key, version, :expires_in => nil)
+
+          version
+        end
+
+        def check(entry)
+          return entry unless entry.is_a?(Store::Entry)
+          return entry.value if entry.tags.blank?
+
+          tags = Tag.build(entry.tags.keys)
+
+          saved_versions = entry.tags.values.map(&:to_i)
+          current_versions = read_multi(tags).values.map(&:to_i)
+
+          saved_versions == current_versions ? entry.value : nil
+        end
+
+        private
+        def read_multi(tags)
+          @cache.read_multi_without_tags(*Array.wrap(tags).map(&:to_key))
+        end
+      end # class Set
+    end # module Tags
+  end # module Cache
+end # module Rails

data/lib/rails/cache/tags/store.rb

@@ -1,102 +1,106 @@
 # coding: utf-8
 
+require 'active_support/cache'
+require 'active_support/concern'
+require 'active_support/core_ext/module/aliasing'
+
+require 'rails/cache/tags/set'
+
 module Rails
   module Cache
     module Tags
       module Store
+        extend ActiveSupport::Concern
+
+        included do
+          alias_method_chain :initialize, :tags
+          alias_method_chain :exist?, :tags
+          alias_method_chain :read, :tags
+          alias_method_chain :read_multi, :tags
+          alias_method_chain :write, :tags
+          alias_method_chain :fetch, :tags
+        end
+
         # cache entry (for Dalli mainly)
         Entry = Struct.new(:value, :tags)
 
-        # patched +new+ method
-        def new(*args, &block) #:nodoc:
-          unless acts_like?(:cached_tags)
-            extend ClassMethods
-            include InstanceMethods
+        attr_reader :tag_set
 
-            alias_method_chain :read_entry, :tags
-            alias_method_chain :write_entry, :tags
-          end
+        def initialize_with_tags(*args)
+          initialize_without_tags(*args)
 
-          super
+          @tag_set = Set.new(self)
         end
 
-        module ClassMethods #:nodoc:all:
-          def acts_like_cached_tags?
-          end
-        end
+        def read_with_tags(name, options = nil)
+          result = read_without_tags(name, options)
+          entry = @tag_set.check(result)
 
-        module InstanceMethods
-          # Increment the version of tags, so all entries referring to the tags become invalid
-          def delete_tag *names
-            tags = Rails::Cache::Tag.build_tags(names)
+          if entry
+            entry
+          else
+            delete(name)
 
-            tags.each { |tag| tag.increment(self) } unless tags.empty?
+            nil
           end
-          alias delete_by_tag  delete_tag
-          alias delete_by_tags delete_tag
-          alias expire_tag     delete_tag
-
-          protected
-          def read_entry_with_tags(key, options) #:nodoc
-            entry = read_entry_without_tags(key, options)
+        end
 
-            # tags are supported only for ActiveSupport::Cache::Entry or Rails::Cache::Tags::Entry
-            tags = if entry.is_a?(ActiveSupport::Cache::Entry) || entry.is_a?(Entry)
-              entry.tags
+        def write_with_tags(name, value, options = nil)
+          if options && options[:tags].present?
+            tags = Tag.build(options[:tags])
+            tags_hash = tags.each_with_object(Hash.new) do |tag, hash|
+              hash[tag.name] = tag_set.current(tag)
             end
 
-            if tags.is_a?(Hash) && tags.present?
-              current_versions = fetch_tags(entry.tags.keys).values
-              saved_versions   = entry.tags.values
-
-              if current_versions != saved_versions
-                delete_entry(key, options)
+            value = Entry.new(value, tags_hash)
+          end
 
-                return nil
-              end
-            end
+          write_without_tags(name, value, options)
+        end
 
-            entry.is_a?(Entry) ?
-                entry.value :
-                entry
-          end # def read_entry_with_tags
+        def exist_with_tags?(name, options = nil)
+          exist_without_tags?(name, options) && !read(name).nil?
+        end
 
-          def write_entry_with_tags(key, entry, options) #:nodoc:
-            tags = Rails::Cache::Tag.build_tags Array.wrap(options[:tags]).flatten.compact
+        def read_multi_with_tags(*names)
+          result = read_multi_without_tags(*names)
 
-            if entry && tags.present?
-              options[:raw] = false # force :raw => false
+          names.each_with_object(Hash.new) do |name, hash|
+            hash[name.to_s] = @tag_set.check(result[name.to_s])
+          end
+        end
 
-              # Dalli treats ActiveSupport::Cache::Entry as deprecated behavior, so we use our own Entry class
-              entry = Entry.new(entry, nil) unless entry.is_a?(ActiveSupport::Cache::Entry)
+        def fetch_with_tags(name, options = nil)
+          return read(name, options) unless block_given?
 
-              entry.tags = fetch_tags(tags).reduce(HashWithIndifferentAccess.new) do |hash, v|
-                tag, value = v
+          yielded = false
 
-                hash[tag.name] = value || tag.increment(self)
+          result = fetch_without_tags(name, options) do
+            yielded = true
+            yield
+          end
 
-                hash
-              end
+          if yielded
+            result
+          else # only :read occured
+            # read occured, and result is fresh
+            if (entry = @tag_set.check(result))
+              entry
+            else # result is stale
+              delete(name)
+              fetch(name, options) { yield }
             end
+          end
+        end
 
-            write_entry_without_tags(key, entry, options)
-          end # def write_entry_without_tags
-
-          private
-          # fetch tags versions from store
-          # fetch ['user/1', 'post/2', 'country/2'] => [Tag('user/1') => 3, Tag('post/2') => 4, Tag('country/2') => nil]
-          def fetch_tags(names) #:nodoc:
-            tags = Rails::Cache::Tag.build_tags names
-            stored = read_multi(*tags.map(&:to_key))
-
-            # build hash
-            tags.reduce(Hash.new) do |hash, t|
-              hash[t] = stored[t.to_key]
-
-              hash
-            end
-          end # def fetch_tags
-        end # module InstanceMethods
+        # Increment the version of tags, so all entries referring to the tags become invalid
+        def delete_tag(*names)
+          tags = Tag.build(names)
+          tags.each { |tag| tag_set.expire(tag) }
+        end
+        alias delete_by_tag  delete_tag
+        alias delete_by_tags delete_tag
+        alias expire_tag     delete_tag
       end # module Store
     end # module Tags
   end # module Cache

data/lib/rails/cache/tags/tag.rb

@@ -0,0 +1,36 @@
+module Rails
+  module Cache
+    module Tags
+      class Tag
+        KEY_PREFIX = '_tags'
+
+        # {:post => ['1', '2', '3']} => [Tag(post/1), Tag(post/2), Tag(post/3)]
+        # {:post => 1, :user => 2} => [Tag(post/1), Tag(user/2)]
+        # ['post/1', 'post/2', 'post/3'] => [Tag(post/1), Tag(post/2), Tag(post/3)]
+        def self.build(names)
+          case names
+            when NilClass then nil
+            when Hash then names.map do |key, value|
+              Array.wrap(value).map { |v| new([key, v]) }
+            end.flatten
+            when Enumerable then names.map { |v| build(v) }.flatten
+            when self then names
+            else [new(names)]
+          end
+        end
+
+        attr_reader :name
+
+        # Tag constructor
+        def initialize(name)
+          @name = ActiveSupport::Cache.expand_cache_key name
+        end
+
+        # real cache key
+        def to_key
+          [KEY_PREFIX, @name].join('/')
+        end
+      end
+    end
+  end
+end

data/lib/rails/cache/tags/version.rb

@@ -1,7 +1,7 @@
 module Rails
   module Cache
     module Tags
-      VERSION = "1.2.0"
+      VERSION = "1.3.0"
     end
   end
 end

data/spec/cache_tags_spec.rb

@@ -0,0 +1,171 @@
+# coding: utf-8
+
+require 'spec_helper'
+require 'fileutils'
+require 'active_support/core_ext'
+
+describe Rails::Cache::Tags do
+  shared_examples 'cache with tags support for' do |object|
+    before { cache.clear }
+
+    def assert_read(key, object)
+      expect(cache.exist?(key)).to eq !!object
+      expect(cache.read(key)).to eq object
+    end
+
+    def assert_blank(key)
+      assert_read key, nil
+    end
+
+    it 'reads and writes a key with tags' do
+      cache.write 'foo', object, :tags => 'baz'
+
+      assert_read 'foo', object
+    end
+
+    it 'deletes a key if tag is deleted' do
+      cache.write('foo', object, :tags => 'baz')
+      cache.delete_tag 'baz'
+
+      assert_blank 'foo'
+    end
+
+    it 'reads a key if another tag was deleted' do
+      cache.write('foo', object, :tags => 'baz')
+      cache.delete_tag 'fu'
+
+      assert_read 'foo', object
+    end
+
+    it 'reads and writes if multiple tags given' do
+      cache.write('foo', object, :tags => [:baz, :kung])
+
+      assert_read 'foo', object
+    end
+
+    it 'deletes a key if one of tags is deleted' do
+      cache.write('foo', object, :tags => [:baz, :kung])
+      cache.delete_tag :kung
+
+      assert_blank 'foo'
+    end
+
+    #it 'does not read a key if it is expired' do
+    #  ttl = 0.01
+    #  # dalli does not support float TTLs
+    #  ttl *= 100 if cache.class.name == 'ActiveSupport::Cache::DalliStore'
+    #
+    #  cache.write 'foo', object, :tags => [:baz, :kung], :expires_in => ttl
+    #
+    #  sleep ttl * 2
+    #
+    #  assert_blank 'foo'
+    #end
+
+    it 'reads and writes a key if hash of tags given' do
+      cache.write('foo', object, :tags => {:baz => 1})
+      assert_read 'foo', object
+
+      cache.delete_tag :baz => 2
+      assert_read 'foo', object
+
+      cache.delete_tag :baz => 1
+      assert_blank 'foo'
+    end
+
+    it 'reads and writes a key if array of object given as tags' do
+      tag1 = 1.day.ago
+      tag2 = 2.days.ago
+
+      cache.write 'foo', object, :tags => [tag1, tag2]
+      assert_read 'foo', object
+
+      cache.delete_tag tag1
+      assert_blank 'foo'
+    end
+
+    it 'reads multiple keys with tags check' do
+      cache.write 'foo', object, :tags => :bar
+      cache.write 'bar', object, :tags => :baz
+
+      assert_read 'foo', object
+      assert_read 'bar', object
+
+      cache.delete_tag :bar
+
+      assert_blank 'foo'
+      assert_read 'bar', object
+
+      expect(cache.read_multi('foo', 'bar')).to eq('foo' => nil, 'bar' => object)
+    end
+
+    it 'fetches key with tag check' do
+      cache.write 'foo', object, :tags => :bar
+
+      expect(cache.fetch('foo') { 'baz' }).to eq object
+      expect(cache.fetch('foo')).to eq object
+
+      cache.delete_tag :bar
+
+      expect(cache.fetch('foo')).to be_nil
+      expect(cache.fetch('foo', :tags => :bar) { object }).to eq object
+      assert_read 'foo', object
+
+      cache.delete_tag :bar
+
+      assert_blank 'foo'
+    end
+  end
+
+  class ComplexObject < Struct.new(:value)
+  end
+
+  SCALAR_OBJECT = 'bar'
+  COMPLEX_OBJECT = ComplexObject.new('bar')
+
+  shared_examples 'cache with tags support' do |*tags|
+    context '', tags do
+      include_examples 'cache with tags support for', SCALAR_OBJECT
+      include_examples 'cache with tags support for', COMPLEX_OBJECT
+
+      # test everything with locale cache
+      include_examples 'cache with tags support for', SCALAR_OBJECT do
+        include ActiveSupport::Cache::Strategy::LocalCache
+
+        around(:each) do |example|
+          if cache.respond_to?(:with_local_cache)
+            cache.with_local_cache { example.run }
+          end
+        end
+      end
+
+      include_examples 'cache with tags support for', COMPLEX_OBJECT do
+        include ActiveSupport::Cache::Strategy::LocalCache
+
+        around(:each) do |example|
+          cache.with_local_cache { example.run }
+        end
+      end
+    end
+  end
+
+  it_should_behave_like 'cache with tags support', :memory_store do
+    let(:cache) { ActiveSupport::Cache.lookup_store(:memory_store, :expires_in => 60, :size => 100) }
+  end
+
+  it_should_behave_like 'cache with tags support', :file_store do
+    let(:cache_dir) { File.join(Dir.pwd, 'tmp_cache') }
+    before { FileUtils.mkdir_p(cache_dir) }
+    after  { FileUtils.rm_rf(cache_dir) }
+
+    let(:cache) { ActiveSupport::Cache.lookup_store(:file_store, cache_dir, :expires_in => 60) }
+  end
+
+  it_should_behave_like 'cache with tags support', :memcache, :mem_cache_store do
+    let(:cache) { ActiveSupport::Cache.lookup_store(:mem_cache_store, :expires_in => 60) }
+  end
+
+  it_should_behave_like 'cache with tags support', :memcache, :dalli_store do
+    let(:cache) { ActiveSupport::Cache.lookup_store(:dalli_store, :expires_in => 60) }
+  end
+end