cachier 0.0.1

data/lib/cachier.rb

@@ -0,0 +1,104 @@
+# Cachier
+module Cachier
+  extend self
+
+  CACHE_KEY = 'cachier-tags'
+
+  def perform_caching?
+    ::ApplicationController.perform_caching
+  end
+
+  # Fetch from cache, this function accepts a block
+  def fetch(cache_key, cache_params = {})
+    tags = cache_params.delete(:tag) || []
+    store_fragment(cache_key, tags)
+
+    if block_given?
+      returned_object = Rails.cache.fetch(cache_key, cache_params) {
+        yield
+      }  
+    else
+      Rails.cache.read(cache_key)
+    end
+  end
+
+  def store_fragment(fragment, *tags)
+    return unless perform_caching?
+
+    tags.each do |tag|
+      fragments = Rails.cache.fetch(tag) || []
+      Rails.cache.write(tag, fragments + [fragment])
+    end
+
+    add_tags_to_tag_list(tags)
+  end
+
+  def expire(*tags)
+    return unless perform_caching?
+
+    # delete them from the cache
+    tags.each do |tag|
+      if fragment_keys = Rails.cache.fetch(tag)
+        fragment_keys.each do |fragment_key|
+          Rails.cache.delete(fragment_key)
+        end
+      end
+      
+      Rails.cache.delete(tag)
+    end
+
+    # now remove them from the list
+    # of stored tags
+    remove_tags_from_tag_list(tags)
+  end
+
+  def tags
+    Rails.cache.fetch(CACHE_KEY) || []
+  end
+
+  def clear
+    expire(*tags)
+    Rails.cache.delete(CACHE_KEY)
+  end
+
+  def wipe
+    clear
+  end
+
+  def keys
+    tags.inject([]) do |arry, tag|
+      arry += (Rails.cache.fetch(tag) || [])
+    end.compact
+  end
+
+  def keys_for(tag)
+    Rails.cache.fetch(tag) || []
+  end
+
+  private
+    def add_tags_to_tag_list(*tags)
+      cachier_tags = get_cachier_tags
+
+      cachier_tags = (cachier_tags + tags).uniq
+      write_cachier_tags(cachier_tags)
+    end
+
+    def write_cachier_tags(cachier_tags)
+      Rails.cache.write(CACHE_KEY, cachier_tags)
+    end
+
+    def remove_tags_from_tag_list(*tags)
+      cachier_tags = get_cachier_tags
+
+      cachier_tags = (cachier_tags - tags).uniq
+      write_cachier_tags(cachier_tags)
+    end
+
+    def get_cachier_tags
+      cachier_tags = Rails.cache.fetch(CACHE_KEY) || []
+      cachier_tags
+    end
+end
+
+require 'cachier/controller_helper'
+require 'cachier/matchers'

data/lib/cachier/controller_helper.rb

@@ -0,0 +1,34 @@
+# Hooks into ApplicationController's write_fragment method.
+# write_fragment is used for action and fragment caching.
+# Create an alias method chain to call our customer method
+# which stores the associated key with the tag in a 
+# Redis Set. Then we can expire all those keys from anywhere
+# in the code using Rails.cache.delete
+#
+# I use alias_method_chain instead of calling 'super'
+# because there is a very rare case where someone 
+# may have redfined 'write_fragment' in their own 
+# controllers. Using an alias method chain
+# keeps those methods intact.
+
+module Cachier
+  module ControllerHelper
+    def self.included(klass)
+      klass.class_eval do
+        def write_fragment_with_tagged_key(key, content, options = nil)
+          if options && options[:tag] && Cachier.perform_caching? 
+            tags = case options[:tag].class.to_s
+                   when 'Proc', 'Lambda'
+                     options[:tag].call(self)
+                   else 
+                     options[:tag]
+                   end
+            Cachier.store_fragment fragment_cache_key(key), *tags
+          end
+          write_fragment_without_tagged_key(key, content, options)
+        end
+        alias_method_chain :write_fragment, :tagged_key
+      end
+    end
+  end
+end  

data/lib/cachier/cucumber.rb

@@ -0,0 +1,6 @@
+World(Cachier::Matchers)
+
+Before('@caching') do
+  Cachier.clear
+  Rails.cache.clear
+end

data/lib/cachier/matchers.rb

@@ -0,0 +1,39 @@
+module Cachier
+  module Matchers
+
+    def be_cached
+      Cache.new
+    end
+
+    class Cache
+      def matches?(target)
+        @target = target
+
+        @test_results = Cachier.keys_for(@target).inject({}) do |hash, key|
+          hash.merge(key => Rails.cache.exist?(key))
+        end
+
+        flag = @test_results.values.inject(true) { |f, v| f && v }
+        flag && Cachier.keys_for(@target).present?
+      end
+
+      def failure_message_for_should
+        <<-msg
+          expected the Rails.cache to include all these keys:
+          #{Cachier.keys_for(@target).to_sentence}, but
+          it did not include these keys:
+          #{@test_results.keys.select {|k| @test_results[k] == false }.to_sentence}
+        msg
+      end
+
+      def failure_message_for_should_not
+        <<-msg
+          expected the Rails.cache to not include all these keys:
+          #{Cachier.keys_for(@target).to_sentence}, but
+          it did include these keys:
+          #{@test_results.keys.select {|k| @test_results[k] == true }.to_sentence}
+        msg
+      end
+    end
+  end
+end

data/lib/cachier/version.rb

@@ -0,0 +1,3 @@
+module Cachier
+  VERSION = "0.0.1"
+end

data/lib/controller_helper.rb

@@ -0,0 +1,34 @@
+# Hooks into ApplicationController's write_fragment method.
+# write_fragment is used for action and fragment caching.
+# Create an alias method chain to call our customer method
+# which stores the associated key with the tag in a 
+# Redis Set. Then we can expire all those keys from anywhere
+# in the code using Rails.cache.delete
+#
+# I use alias_method_chain instead of calling 'super'
+# because there is a very rare case where someone 
+# may have redfined 'write_fragment' in their own 
+# controllers. Using an alias method chain
+# keeps those methods intact.
+
+module Cashier
+  module ControllerHelper
+    def self.included(klass)
+      klass.class_eval do
+        def write_fragment_with_tagged_key(key, content, options = nil)
+          if options && options[:tag] && Cashier.perform_caching? 
+            tags = case options[:tag].class.to_s
+                   when 'Proc', 'Lambda'
+                     options[:tag].call(self)
+                   else 
+                     options[:tag]
+                   end
+            Cashier.store_fragment fragment_cache_key(key), *tags
+          end
+          write_fragment_without_tagged_key(key, content, options)
+        end
+        alias_method_chain :write_fragment, :tagged_key
+      end
+    end
+  end
+end  

data/lib/cucumber.rb

@@ -0,0 +1,6 @@
+World(Cashier::Matchers)
+
+Before('@caching') do
+  Cashier.clear
+  Rails.cache.clear
+end

data/lib/matchers.rb

@@ -0,0 +1,39 @@
+module Cashier
+  module Matchers
+
+    def be_cached
+      Cache.new
+    end
+
+    class Cache
+      def matches?(target)
+        @target = target
+
+        @test_results = Cashier.keys_for(@target).inject({}) do |hash, key|
+          hash.merge(key => Rails.cache.exist?(key))
+        end
+
+        flag = @test_results.values.inject(true) { |f, v| f && v }
+        flag && Cashier.keys_for(@target).present?
+      end
+
+      def failure_message_for_should
+        <<-msg
+          expected the Rails.cache to include all these keys:
+          #{Cashier.keys_for(@target).to_sentence}, but
+          it did not include these keys:
+          #{@test_results.keys.select {|k| @test_results[k] == false }.to_sentence}
+        msg
+      end
+
+      def failure_message_for_should_not
+        <<-msg
+          expected the Rails.cache to not include all these keys:
+          #{Cashier.keys_for(@target).to_sentence}, but
+          it did include these keys:
+          #{@test_results.keys.select {|k| @test_results[k] == true }.to_sentence}
+        msg
+      end
+    end
+  end
+end

data/lib/railtie.rb

@@ -0,0 +1,8 @@
+module Cashier
+  class Railtie < Rails::Railtie
+    initializer 'cashier.initialize' do
+      ApplicationController.send :include, Cashier::ControllerHelper
+    end
+  end
+end
+

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Cashier
+  VERSION = "0.2.0"
+end

metadata

@@ -0,0 +1,131 @@
+--- !ruby/object:Gem::Specification 
+name: cachier
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Avi Tzurel
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-10-19 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: hiredis
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: redis
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: redis-namespace
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+description: Tag your cache keys smartly, you can expire by tags, count keys per tag and many more. based on Redis
+email: avi@kensodev.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/cachier/controller_helper.rb
+- lib/cachier/cucumber.rb
+- lib/cachier/matchers.rb
+- lib/cachier/version.rb
+- lib/cachier.rb
+- lib/controller_helper.rb
+- lib/cucumber.rb
+- lib/matchers.rb
+- lib/railtie.rb
+- lib/version.rb
+has_rdoc: true
+homepage: https://github.com/KensoDev/cachier
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- .
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Tagging ability for your cache keys, based on Redis
+test_files: []
+