itrigga-cache 0.2.1

data/.document

@@ -0,0 +1,5 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+gem "memcached"
+gem "itrigga-param_fu"
+
+group :development do
+  gem "rspec", "1.3.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,24 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    git (1.2.5)
+    itrigga-param_fu (0.0.1)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    memcached (1.3.5)
+    rake (0.8.7)
+    rcov (0.9.11)
+    rspec (1.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  itrigga-param_fu
+  jeweler (~> 1.6.4)
+  memcached
+  rcov
+  rspec (= 1.3.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Anson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.rdoc

@@ -0,0 +1,79 @@
+= itrigga-cache
+
+Adds methods to models and controllers to help caching output.
+
+== Models
+With models use like below to cache the output of the block
+
+with_cache(:key => "unique_key") do
+  Model.find(:all)
+end
+
+To use a different timeout use the below. (Only supported for memcached backend. Filecache uses the value from setup!)
+
+with_cache(:key => "unique_key", :timeout => 42) do
+  Model.find(:all)
+end
+
+== Controllers
+With controllers use like:
+
+with_controller_cache do
+  @items = Item.new_on_site(:site_id=>@current_site.id, :page=>params[:page], :per_page=>params[:per_page])
+end
+
+This will
+- call the block
+- render the content
+- cache the *rendered* output
+- set the :content_type according to the pasted in value (defaults to 'text/html')
+To bypass the cache just have the "freshen" => true key in the params (ie as a query string param). This will force fresh the cache
+
+
+== Installation
+In environment.rb: 
+config.gem 'itrigga-cache', :lib=>'itrigga/cache'
+
+In application_controller
+require 'itrigga/cache'
+include Itrigga::Cache
+Itrigga::Cache.setup!
+
+Itrigga::Cache.setup! initializes a cache instance. Memcache and filecache are currently supported
+
+Itrigga::Cache.setup! :backend => :memcached
+Options are:
+:servers - ip:port of the memcache instances to use
+:timeout - the default life of the cache item
+Any other options get passed to the memcached initializer - see https://github.com/fauna/memcached for more info
+
+
+Itrigga::Cache.setup! :backend => :filecache
+Options are:
+:cache_dir - the file path to where the cache files will live
+:timeout - how long the cache key is valid for
+
+Itrigga::Cache.setup! can be called as many times as you like, for as many backends as you like.
+The cache gem will use the last defined (setup) backend as the default backend.
+
+Use the :backend option to force a backend
+with_cache(:key => "unique_key", :backend => :memcached) do
+  Model.find(:all)
+end
+
+
+== Contributing to itrigga-cache
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Anson. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,52 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "itrigga-cache"
+  gem.homepage = "http://gemcutter.com/gems/itrigga-cache"
+  gem.license = "MIT"
+  gem.summary = %Q{Adds caching methods}
+  gem.description = %Q{Wraps memcached with helpful methods}
+  gem.email = "support@itrigga.com"
+  gem.authors = ["Al Davidson","Anson Kelly"]
+  # dependencies defined in Gemfile
+  gem.add_dependency "memcached"
+  gem.add_dependency "itrigga-param_fu"
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'spec/version'
+require 'spec/rake/spectask'
+require 'spec/ruby'
+
+Spec::Rake::SpecTask.new(:spec) do |spec|
+  spec.spec_files = FileList['spec/**/*_spec.rb']
+  spec.spec_opts = ['--options', 'spec/spec.opts']
+end
+
+task :default => :spec
+
+desc "Run all specs with rcov"
+Spec::Rake::SpecTask.new(:rcov) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = ['--options', 'spec/spec.opts']
+  t.rcov = true
+  t.rcov_dir = 'coverage'
+  t.rcov_opts = ['--exclude', "features,kernel,load-diff-lcs\.rb,instance_exec\.rb,lib/spec.rb,lib/spec/runner.rb,^spec/*,bin/spec,examples,/gems,/Library/Ruby,\.autotest,#{ENV['GEM_HOME']}"]
+  t.rcov_opts << '--sort coverage --text-summary --aggregate coverage.data'
+end
+
+
+

data/VERSION

@@ -0,0 +1 @@
+0.2.1

data/lib/itrigga/cache/cache.rb

@@ -0,0 +1,195 @@
+require 'memcached'
+require 'trigga/param_fu'
+
+module Itrigga
+  module Cache
+    
+    @@ITRIGGA_CACHE_TYPE = :filecache
+    
+    def self.included(base)
+      base.extend(ClassMethods)
+      base.send(:include, InstanceMethods)
+      base.send(:include, Trigga::ParamFu)
+      base.send(:include, ControllerMethods) if defined?(ActionController::Base) && base.ancestors.include?(ActionController::Base)
+    end
+    
+    def self.setup!(opts ={})
+      if opts[:backend] == :memcached
+        @@ITRIGGA_CACHE_TYPE = :memcached
+        Itrigga::Cache::Memcache.setup!(opts)       
+      else
+        Itrigga::Cache::Filecache.setup!(opts)
+      end
+    end
+    
+    def self.instance(opts = {})
+      case ( opts[:backend] ||= @@ITRIGGA_CACHE_TYPE )
+        when :memcached          
+          Itrigga::Cache::Memcache.instance
+        when :filecache
+          Itrigga::Cache::Filecache.instance
+        else
+          nil
+      end
+    end
+    
+    
+    module InstanceMethods
+      
+      def with_cache(opts = {}, &block)
+        self.class.with_cache(opts, &block)
+      end
+      
+      def caching_enabled?(opts = {})
+        self.class.caching_enabled?(opts)
+      end
+      
+      
+      
+      def get_from_cache(key, opts = {})
+        self.class.get_from_cache(key, opts)
+      end
+      
+      def set_to_cache(key, value, opts = {})
+        self.class.set_to_cache(key, value, opts)
+      end
+      
+      def delete_from_cache(key, opts = {})
+        self.class.delete_from_cache(key, opts)
+      end
+      
+      
+      def cache_log(text, opts = {})
+        self.class.cache_log(text, opts)
+      end
+      
+    end
+    
+    module ClassMethods
+      
+      def with_cache(opts = {}, &block)
+        require_param(opts, :key)
+        
+        # if no cache then just return whatever the block gives us
+        unless caching_enabled?(opts)
+          cache_log "Cache not enabled!", opts
+          return block.call
+        end
+        
+        # see if the key is already in cache
+        value = get_from_cache(opts[:key], opts)
+        
+        # if no match then call the block and save result in cache
+        unless value
+          cache_log "Key '#{opts[:key]}' missing! Calling block and setting in cache", opts
+          value = block.call
+          set_to_cache(opts.delete(:key), value, opts) rescue value # incase memcache crashes or whateversolr1-internal-itrigga.dyndns-ip.com solr1-internal-itrigga.dyndns-ip.com            
+        else
+          cache_log "Key '#{opts[:key]}' found in cache!", opts
+        end
+    
+        value
+      end
+      
+      
+      def caching_enabled?(opts = {})
+        Itrigga::Cache.instance(opts).enabled == true
+      end
+      
+      
+      
+      
+      
+      def get_from_cache(key, opts = {})
+        return nil unless caching_enabled?(opts)
+        cache_log "get_from_cache key: #{key},  opts: #{opts.inspect}" #if opts[:debug]
+        begin
+          Itrigga::Cache.instance(opts).get key
+        rescue Memcached::NotFound => not_found
+          # we dont care 
+          nil
+        rescue Exception => e
+          cache_log "Exception in get_from_cache: #{e.message}"
+          nil
+        end
+      end
+      
+      
+      
+      def set_to_cache(key, value, opts = {})
+        raise "Cache not Enabled" unless caching_enabled?(opts)
+              
+        cache_log "set_to_cache key: #{key}, value: #{value}, opts: #{opts.inspect}"# if opts[:debug]
+        begin
+          Itrigga::Cache.instance(opts).set key, value, opts
+        rescue Exception => e
+          cache_log "Exception in set_to_cache: #{e.message}"
+        end
+          
+        value
+      end
+      
+      
+      def delete_from_cache(key, opts = {})
+        return nil unless caching_enabled?(opts)
+        begin
+          cache_log "Deleting key #{key}", opts  
+          Itrigga::Cache.instance(opts).delete key
+        rescue Exception => e
+          nil
+        end
+      end
+      
+      
+      def cache_log(text, opts = {})
+        message = "[CACHE] [#{opts[:backend] }] #{text}"
+        defined?(Rails.logger) && Rails.logger ? Rails.logger.info(message) : puts(message)
+      end
+        
+    end
+    
+    
+    module ControllerMethods
+      
+      def with_controller_cache( opts = {}, &block )  
+
+        if caching_enabled?(opts)
+        
+          opts[:key] = opts[:cache_key] || opts[:key] || (respond_to?(:cache_key) ? cache_key.to_s : nil)  # backwards compat using :cache_key
+          raise ArgumentError("No cache key found") unless opts[:key]
+          
+          begin
+          
+            if params && params.kind_of?(Hash) && params["freshen"]
+              delete_from_cache opts[:key], opts       
+            end
+              
+            @content = with_cache(opts, &block) 
+            @content ||= render_to_string unless performed?                
+                
+          rescue Exception => ex
+            cache_log "Error when rendering cache block: #{ex.message}", opts
+            @content ||= block.call
+            @content ||= render_to_string unless performed?
+          end
+          
+          # flashes need to be rendered and replaced every request if we're in a html request
+          render_flashes if request.format.html? && respond_to?(:render_flashes)
+        
+        else # cache is not enabled so just render the block
+          cache_log "Cache not enabled!", opts
+          @content ||= block.call
+          @content ||= render_to_string unless performed?
+        end
+        
+        render(:text=>@content, :content_type=>( @content_type || "text/html")) unless performed?
+        
+        @content
+        
+      end
+            
+      
+    end
+    
+  end
+end

data/lib/itrigga/cache/filecache.rb

@@ -0,0 +1,63 @@
+# http://stackoverflow.com/questions/4217968/a-problem-about-singleton-in-ruby
+
+#
+#  To implement a backend it needs to respond to:
+#  - self.setup!
+#  - get
+#  - set
+#  - delete
+# 
+
+
+require 'singleton'
+
+module Itrigga
+  module Cache
+    
+    class Filecache
+      include Singleton 
+      
+      attr_accessor :cache_dir, :timeout, :enabled
+      
+      def self.setup!(opts = {})
+        instance.cache_dir =  opts[:cache_dir] || "#{defined?(RAILS_ROOT) ? RAILS_ROOT : ''}/tmp/cache"
+        instance.timeout = opts[:timeout] || 3600
+        instance.enabled = true
+        instance
+      end
+      
+      def get(key, opts = {})
+        if expired?(key, opts)
+          delete(key, opts)
+          nil
+        else
+          File.open( file_path(key, opts), 'r' ){ |f| f.read } if is_in_cache?(key, opts)
+        end
+      end
+      
+      def set(key, content, opts = {})
+        File.open( file_path(key, opts), 'w' ){ |f| f.write(content) }
+      end
+      
+      def delete(key, opts = {})
+        File.delete( file_path(key, opts)) if is_in_cache?(key, opts)
+      end
+      
+      def file_path(key, opts = {})
+        File.expand_path(File.join(opts[:cache_dir] || cache_dir, key ))
+      end
+      
+      def is_in_cache?(key, opts={} )        
+        File.exists?( file_path(key, opts) )
+      end
+      
+      def expired?(key, opts={} ) 
+        return true unless is_in_cache?(key, opts)
+        opts[:timeout] ||= timeout
+        Time.now - File.mtime(file_path(key, opts)) > opts[:timeout].to_i
+      end      
+      
+    end
+    
+  end
+end

data/lib/itrigga/cache/memcache.rb

@@ -0,0 +1,55 @@
+# http://stackoverflow.com/questions/4217968/a-problem-about-singleton-in-ruby
+#
+#  To implement a backend it needs to respond to:
+#  - self.setup!
+#  - get
+#  - set
+#  - delete
+#
+
+require 'singleton'
+
+module Itrigga
+  module Cache
+
+    class Memcache
+      include Singleton
+        
+        attr_accessor :cache, :enabled
+        
+        def initialize
+          @cache = nil
+        end
+      
+        def self.setup!(opts = {})
+          servers = opts[:servers] || "localhost:11211"
+          opts.delete(:servers)
+          
+          opts[:default_ttl] ||= opts[:timeout] if opts[:timeout] # rename default_ttl to something easier to use
+          opts.delete(:timeout)
+          instance.enabled = true
+          
+          puts "Memcached init with: #{servers.inspect} - #{opts.inspect}"
+          instance.cache = ::Memcached.new(servers, opts)   
+        end    
+        
+        def get(key, opts = {})
+          cache.get key
+        end
+        
+        def set(key, value, opts = {})
+          if opts[:timeout]
+            cache.set key, value, opts[:timeout]
+          else
+            cache.set key, value
+          end
+        end
+        
+        def delete(key, opts = {})
+          cache.delete key
+        end
+        
+      end
+
+  end
+end

data/lib/itrigga/cache.rb

@@ -0,0 +1 @@
+Dir[File.expand_path(File.join(File.dirname(__FILE__),"cache","*.rb"))].each{|f| require f }

data/spec/filecache_spec.rb

@@ -0,0 +1,155 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Itrigga::Cache::Filecache do
+  before do
+    Itrigga::Cache::Filecache.reset_instance
+    @file = mock("File")
+    @file.stub!(:read).and_return("content")
+    @file.stub!(:write)
+    File.stub!(:open).and_yield(@file)
+    File.stub!(:delete)
+    File.stub!(:exists?).and_return(false)
+    @instance = Itrigga::Cache::Filecache.instance
+    @opts = {}
+  end
+  
+  it "should include Singleton" do
+    Itrigga::Cache::Filecache.should include Singleton
+  end
+  
+  describe "setup!" do
+    describe "when given no options" do
+      it "should assign default cache_dir" do
+        Itrigga::Cache::Filecache.setup!
+        Itrigga::Cache::Filecache.instance.cache_dir.should == "#{RAILS_ROOT}/tmp/cache"
+      end
+      
+      it "should assign default timeout" do
+        Itrigga::Cache::Filecache.setup!
+        Itrigga::Cache::Filecache.instance.timeout.should == 3600
+      end
+    end
+    
+    it "should assign the given cache_dir" do
+      Itrigga::Cache::Filecache.setup! :cache_dir => "monkeys"
+      Itrigga::Cache::Filecache.instance.cache_dir.should == "monkeys"
+    end
+    
+    it "should assign the given timeout" do
+      Itrigga::Cache::Filecache.setup! :timeout => 42
+      Itrigga::Cache::Filecache.instance.timeout.should == 42
+    end
+    
+    it "should return the instance" do
+      Itrigga::Cache::Filecache.setup!().should be_a_kind_of Itrigga::Cache::Filecache
+    end
+  end
+  
+  
+  describe "instance methods" do
+    before do
+      Itrigga::Cache::Filecache.setup! # need to set the defaults on the instance
+      @file_path = "#{RAILS_ROOT}/tmp/cache/key"
+    end
+  
+    describe "get" do
+      describe "when expired" do
+        before do
+          @instance.stub!(:expired?).and_return(true)
+        end
+        
+        it "should call delete" do
+          @instance.should_receive(:delete).with("key", @opts)
+          @instance.get("key", @opts)
+        end
+        
+        it "should return nil" do
+          @instance.get("key", @opts).should == nil
+        end
+      end
+        
+      describe "when not expired" do
+        before do
+          @instance.stub!(:expired?).and_return(false)
+        end
+        
+        it "should read the file when the file exists" do
+          @instance.stub!(:is_in_cache?).and_return(true)
+          File.should_receive(:open).with(@file_path,'r').and_yield(@file)
+          @file.should_receive(:read).and_return("content")
+          @instance.get("key", @opts).should == "content"
+        end
+        
+        it "should not try to read the file if not exist" do
+          @instance.stub!(:is_in_cache?).and_return(false)
+          File.should_not_receive(:open).with(@file_path,'r')
+          @instance.get("key", @opts).should == nil
+        end
+      end
+    end
+    
+    
+    
+    describe "set" do
+      it "should write the content to file" do
+        File.should_receive(:open).with(@file_path,'w').and_yield(@file)
+        @file.should_receive(:write).with("content")
+        @instance.set("key","content",@opts)
+      end
+    end
+    
+    
+    
+    describe "delete" do
+      describe "when the file exists" do
+        before do
+          @instance.stub!(:is_in_cache?).and_return(true)
+        end
+        
+        it "should call File.delete" do
+          File.should_receive(:delete).with(@file_path)
+          @instance.delete("key")
+        end
+      end
+      
+      describe "when the file does not exists" do
+        before do
+          @instance.stub!(:is_in_cache?).and_return(false)
+        end
+        
+        it "should call File.delete" do
+          File.should_not_receive(:delete)
+          @instance.delete("key")
+        end
+      end
+    end
+    
+    
+    describe "expired?" do
+      describe "when file is not in cache" do
+        it "should return true" do
+          @instance.should_receive(:is_in_cache?).with("key",@opts).and_return(false)
+          @instance.expired?("key", @opts).should == true
+        end
+      end
+      
+      describe "when file is in cache" do
+        before do
+          @instance.stub!(:is_in_cache?).and_return(true)
+          Time.stub!(:now).and_return(42)
+          File.stub!(:mtime).and_return(20)
+        end
+        
+        it "should return false if not expired" do
+          @instance.expired?("key",@opts).should == false
+        end
+        
+        it "should return true if expired" do
+          @instance.expired?("key",{:timeout => 5}).should == true
+        end
+      end
+    end
+    
+  end
+   
+end