that_old_cache 0.0.1

data/README.md

@@ -0,0 +1,16 @@
+That Old Cache
+==============
+
+Description
+-----------
+
+Getting sick of memcached just kicking your stuff out of memory in Rails? Maybe you've thought
+*"Gee, wouldn't it be nice to just serve the old cache while I refresh it."* Well, look no
+further! **That Old Cache** is a Rubygem that does just that, giving you the ability to fire
+off a process to refresh the cache once it expires, without the annoying "initial load" problem
+that affects your users.
+
+Authors
+-------
+
+Joey Robert ([http://joeyrobert.org/](http://joeyrobert.org/))

data/Rakefile

@@ -0,0 +1,34 @@
+require 'rubygems'
+require 'rake'
+require 'rake/gempackagetask'
+require 'spec/rake/spectask'
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc 'Run the specs'
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_opts = ['--colour --format progress --loadby mtime --reverse']
+  t.spec_files = FileList['spec/**/*_spec.rb']
+end
+
+PKG_FILES = FileList['lib/**/*', 'spec/*', 'Rakefile', 'README.md', 'VERSION']
+
+spec = Gem::Specification.new do |s|
+  s.name = "that_old_cache"
+  s.version = "0.0.1"
+  s.author = "Joey Robert"
+  s.email = "joey@joeyrobert.org"
+  s.homepage = "http://github.com/joeyrobert/that_old_cache"
+  s.platform = Gem::Platform::RUBY
+  s.summary = "Serve old caches from memcached while you update in Rails"
+  s.description = "An ActiveSupport MemCache store that requires serves keys until they are explicitly overwritten"
+  s.files = PKG_FILES.to_a
+  s.require_path = "lib"
+  s.has_rdoc = false
+  s.add_dependency "yajl-ruby", ">= 0.7.x"
+  s.add_dependency "activesupport", ">= 2.3.x"
+end
+
+desc 'Turn this plugin into a gem.'
+Rake::GemPackageTask.new(spec) { |pkg| pkg.gem_spec = spec }

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/lib/that_old_cache.rb

@@ -0,0 +1 @@
+require 'that_old_cache/ttled_mem_cache_store'

data/lib/that_old_cache/ttled_mem_cache_store.rb

@@ -0,0 +1,60 @@
+require 'active_support'
+require 'yajl'
+
+module ActiveSupport
+  module Cache
+    class TTLedMemCacheStore < MemCacheStore
+      # Adds the following option:
+      #   :valid_for => number of seconds from now that the cache with "expire"
+      #   :raw is not supported with :valid_for
+      def write(key, value, options = nil)
+        if options && options[:valid_for]
+          options.delete(:raw)
+          super(key, encode({ :data => value, :ttl => time_for(options.delete(:valid_for)) }), options)
+        else
+          super
+        end
+      end
+
+      # Adds the following option:
+      #   :valid_for => true 
+      #   :raw is not supported with :valid_for
+      def read(key, options = nil)
+        if options && options.delete(:valid_for)
+          options.delete(:raw)
+          parse(super)[:data] rescue nil
+        else
+          super
+        end
+      end
+
+      # only works for TTLed keys
+      def expired?(key)
+        begin
+          ttl(key) < Time.now.to_i
+        rescue NoMethodError 
+          false
+        end
+      end
+
+      # only works for TTLed keys
+      def ttl(key)
+        parse(read(key))[:ttl] rescue nil
+      end
+
+      private
+
+      def time_for(seconds)
+        Time.now.to_i + seconds.to_i
+      end
+      
+      def parse(val)
+        Yajl::Parser.new(:symbolize_keys => true).parse(val)
+      end
+
+      def encode(val)
+        Yajl::Encoder.encode(val)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require "spec"
+require File.dirname(__FILE__) + '/../lib/that_old_cache'

data/spec/that_old_cache_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/spec_helper'
+
+describe ActiveSupport::Cache::TTLedMemCacheStore do
+  # Since this is about interface to a cache, I think it makes sense to run a 
+  # real cache in this case and not mock/stub it out.  TODO: Rake to start/detach
+  # a memcached?
+  before(:all) do
+    begin
+      # Run on non-default port so not to accidentally mess with a real cache
+      @cache = ActiveSupport::Cache::TTLedMemCacheStore.new("127.0.0.1:12345")
+      # Call to make sure we have a live connection
+      @cache.exist?("cache_key")
+    rescue => e
+      $stderr.puts e.message
+      $stderr.puts "Make sure memcached is listening on tcpport 12345: /path/to/memcached -p 12345"
+      exit
+    end
+    
+    @key = "example_key"
+    @value = "example_value"
+  end
+  
+  after(:each) do
+    @cache.clear
+  end
+  
+  context "ttl'd keys" do
+    before(:each) do
+      @valid_for = 10
+      @cache.write(@key, @value, :valid_for => @valid_for)
+    end
+    
+    it "should set the expected value in the cache" do
+      @cache.read(@key, :valid_for => true).should == @value
+    end
+    
+    it "should have the proper ttl" do
+      @cache.ttl(@key).should be_close(Time.now.to_i + @valid_for, 1)
+    end
+    
+    # Vendor something to time_travel if this sleep stuff gets annoying
+    it "should be expired if the ttl is less than now" do
+      @cache.write(@key, @value, :valid_for => 0.1)
+      sleep 1
+      @cache.expired?(@key).should be_true
+    end
+    
+    it "should not be expired if the ttl is greater than now" do
+      @cache.write(@key, @value, :valid_for => 5)
+      @cache.expired?(@key).should be_false
+    end
+  end
+
+  context "non-ttl'd keys" do
+    before(:each) do
+      @cache.write(@key, @value)
+    end
+    
+    it "should set the non-serialized value in the cache" do
+      @cache.read(@key).should == @value
+    end
+    
+    it "should have a nil ttl" do
+      @cache.ttl(@key).should be_nil
+    end
+    
+    it "should not be expired" do
+      @cache.expired?(@key).should be_false
+    end
+    
+    it "should not raise an exception if trying a ttl'd read on a non-ttl'd key" do
+      lambda { @cache.read(@key, :valid_for => true) }.should_not raise_error
+    end
+
+    it "should return nil if trying a ttl'd read on a non-ttl'd key" do
+      @cache.read(@key, :valid_for => true).should be_nil
+    end
+  end  
+end

metadata

@@ -0,0 +1,95 @@
+--- !ruby/object:Gem::Specification 
+name: that_old_cache
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Joey Robert
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-04-13 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: yajl-ruby
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        - 7
+        - x
+        version: 0.7.x
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 2
+        - 3
+        - x
+        version: 2.3.x
+  type: :runtime
+  version_requirements: *id002
+description: An ActiveSupport MemCache store that requires serves keys until they are explicitly overwritten
+email: joey@joeyrobert.org
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/that_old_cache.rb
+- lib/that_old_cache/ttled_mem_cache_store.rb
+- spec/spec_helper.rb
+- spec/that_old_cache_spec.rb
+- Rakefile
+- README.md
+- VERSION
+has_rdoc: true
+homepage: http://github.com/joeyrobert/that_old_cache
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Serve old caches from memcached while you update in Rails
+test_files: []
+