cachecataz 0.1.0

data/.document

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

data/.rspec

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

data/Gemfile

@@ -0,0 +1,13 @@
+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.
+group :development do
+  gem "rspec", "~> 2.3.0"
+  gem "bundler", "~> 1.0.0"
+  gem "jeweler", "~> 1.5.2"
+  gem "rcov", ">= 0"
+end

data/Gemfile.lock

@@ -0,0 +1,28 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rcov (0.9.9)
+    rspec (2.3.0)
+      rspec-core (~> 2.3.0)
+      rspec-expectations (~> 2.3.0)
+      rspec-mocks (~> 2.3.0)
+    rspec-core (2.3.1)
+    rspec-expectations (2.3.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.3.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  jeweler (~> 1.5.2)
+  rcov
+  rspec (~> 2.3.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Brandon Dewitt
+
+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,81 @@
+= cachecataz
+
+Cachecataz is for namespace expiry in a cache where the cache provider does not enable namespace based expiry (like memcached).
+
+Cachecataz creates a namespace key based on a cache_scope defined for the class.  Each cache namespace can be expired through
+an instance or the class.  
+
+== Problem
+
+Cache servers like Memcache only provide expiry for cache keys based on a unique value.
+Don't allow you to specify an entire namespace to expire based on changes in the underlying data. 
+
+== Solution
+
+Store a value in the cache that determines the namespace of the cache key and increment the value of the namespace key each time the 
+namespace needs to be expired.  
+
+= Using Cachecataz
+
+Install it:
+
+  gem install cachecataz
+
+Include it and define your scopes:
+
+  class Element < ActiveRecord::Base
+    include Cachecataz
+    
+    cache_scope :name, [:user_id]
+  end
+  
+A cache_scope is the mechanism to create a unique scope for a namespace.  The namespace key will be comprised of the cache_scope name 
+(in this example "name") and the runtime state of any value passed in the Array of symbols that make up a unique scope.  
+
+For the example above the namespace key would be "name:#{element.user_id}", which allows us to have a unique namespace for each 
+"name" key scoped by the user_id. 
+
+== Example (in Rails)
+
+Basic premise: An Element belongs_to a User and a Widget belongs_to a User as well.  The "something" partial displays data primarily related to 
+the Element but also displays data from the related Widget.  I want to have a sweeper that observes changes in the Widget model and expires the
+namespace for the Element.  (can be kinda confusing, but makes sense in the context of a cache that is model dependent.
+
+Generate a cache key:
+  # ** Model **
+  class Element < ActiveRecord::Base
+    include Cachecataz
+    
+    cache_scope :user, [:user_id]
+  end
+  
+  ** View **
+  <% cache(@element.cache_key(:user, :id)) do %>
+    <% render :partial => "something", :locals => { :widget => @element.widget } %>
+  <% end %>
+  
+  # ** Observer **
+  class WidgetObserver < ActiveRecord::Observer    
+    after_update(widget)
+      Element.expire_namespace(:user, widget.attributes)  # can also just pass {:user_id => widget.user_id} as the scope_hash, scope requires :user_id
+    end
+  end
+
+== TODO
+post more info on how to use cachecataz with a cache that is not Rails.cache (it's very simple), but wanted to get the basics released
+  
+== Contributing to cachecataz
+ 
+* 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 Brandon Dewitt. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,51 @@
+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 = "cachecataz"
+  gem.homepage = "http://github.com/bdewitt/cachecataz"
+  gem.license = "MIT"
+  gem.summary = %Q{cache namespace expiry gem for cache servers that do not have namespace expiry}
+  gem.description = %Q{Cachecataz is for namespace expiry in a cache where the cache provider does not enable namespace based expiry (like memcached!)}
+  gem.email = "brandon+cachecataz@myjibe.com"
+  gem.authors = ["Brandon Dewitt"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  gem.add_development_dependency 'rspec', '> 2'
+end
+
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "cachecataz #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/cachecataz.rb

@@ -0,0 +1,208 @@
+module Cachecataz
+  # Default config for Rails.cache, disabled, and [":", "/"] delims
+  #
+  # @example configure in an environment file (development.rb, production.rb) for Rails
+  #
+  #   config.after_initialize do
+  #     Cachecataz.enable = true
+  #     Cachecataz.provider = Rails.cache
+  #   end
+  Config = {:api => {:get => :read, :set => :write, :incr => :increment, :exist? => :exist?}, 
+            :enabled => false,
+            :ns_delim => ":",
+            :index_delim => "/" }
+    
+  # Config method to enable Cachecataz
+  #
+  # @param [Boolean] val
+  def self.enable=(val)
+    Config[:enabled] = val
+  end
+  
+  # Set custom delimiter if desired
+  def self.delim=(val)
+    Config[:ns_delim] = val.first rescue ":"
+    Config[:index_delim] = val.last rescue "/"
+  end
+  
+  # Config method to assign the provider, for Rails this is Rails.cache
+  #
+  # @param [Object] val an object that responds to the api provided
+  def self.provider=(val)
+    Config[:provider] = val
+  end
+  
+  # Config method that maps the api method calls from the provider to the caching server
+  # example is the mapping for the Rails.cache provider
+  #
+  # @example Cachecataz.api = {:get => :read, :set => :write, :incr => :increment, :exist? => :exist?}
+  # 
+  # @param [Hash] api a hash of symbols or procs/lambdas mapped to each of [:get, :set, :incr, :exist?]
+  def self.api=(api)
+    validate_api(api)
+    Config[:api] = api
+  end  
+  
+  # [] operator to run the actual calls on the cache provider configured
+  def self.[](*api_args)
+    return false if !Config[:enabled]
+    
+    api_method = api_args.slice!(0)
+    
+    if Config[:api][api_method].respond_to?(:call)
+      Config[:api][api_method].call(*api_args)
+    else
+      Config[:provider].send(Config[:api][api_method], *api_args)    
+    end
+  end
+
+  # Method that validates the api and provider if they are defined in configuration
+  def self.validate_api(api={})
+    unless api.include?(:get) && api.include?(:set) && api.include?(:incr) && api.include?(:exist?)
+      raise "Unknown api methods, define [:get, :set, :incr, :exist?] to use cachecataz with a non-standard provider"
+    end
+  end
+  
+  # Method that includes and extends the appropriate modules
+  def self.included(inc_class)
+    inc_class.instance_variable_set(:@_point_keys, {})
+    inc_class.send(:include, Cachecataz::InstanceMethods)
+    inc_class.send(:extend, Cachecataz::ClassMethods)
+  end
+    
+  module ClassMethods    
+    # Takes the cache_point and the value from the cache
+    #
+    # @param [Symbol] point_key the symbol that identifies the namespace point
+    # @param [Hash] scope_hash the hash that provides the data for creating the namespace key
+    # @return [String] cachecataz namespaced cache key
+    def cache_key(point_key, scope_hash)
+      c_point = cache_point(point_key, scope_hash)
+      c_key = Cachecataz[:get, c_point].to_s.strip
+      return "#{c_key}#{Cachecataz::Config[:ns_delim]}" << c_point 
+    end
+    
+    # Determines and returns the cache_point
+    # putting i.to_s first in the scope_hash lookup because primarily using with self.attributes in rails which is string keyed
+    def cache_point(point_key, scope_hash)
+      c_scope = @_point_keys[point_key]   
+      c_point = c_scope.inject(point_key.to_s){|s, i| s << Cachecataz::Config[:ns_delim] << (scope_hash[i.to_s] || scope_hash[i]).to_s }
+      Cachecataz[:set, c_point, "0"] if !Cachecataz[:exist?, c_point]
+      return c_point
+    end
+
+    # Method used in the Class to defined a cachecataz namespace
+    # assigns the scope to a class instance variable with the point_key as key
+    #
+    # @param [Symbol] point_key the name of the cachecataz namespace
+    # @param [Array] c_scope the symbols that defined the scope of the namespace
+    def cache_scope(point_key, *c_scope)
+      c_scope.flatten!
+      c_scope.uniq!
+      c_scope.sort!{|a, b| a.to_s <=> b.to_s}
+      @_point_keys[point_key] = c_scope
+    end
+    
+    # Class level method that expires the namespace in the cache for the point_key and 
+    # scope data provided
+    #
+    # @param [Symbol] point_key 
+    # @param [Hash] scope_hash the data provider for the scope of the namespace
+    def expire_namespace(point_key, scope_hash={})
+      c_point = cache_point(point_key, scope_hash)
+      Cachecataz[:incr, c_point]
+    end
+    
+    # Class level method to expire all the namespace of cachecataz for a given data provider
+    #
+    # @param [Hash] scope_hash the data provider for the scope of the namespace
+    def expire_all_namespaces(scope_hash={})
+      @_point_keys.keys.each{|k| expire_namespace(k, scope_hash)}
+    end
+    
+    # Resets a cache namespace to 0, should be needed, but wanted to have something here to do it
+    def cachecataz_namespace_reset(point_key, scope_hash={})
+      c_point = cache_point(point_key, scope_hash)
+      Cachecataz[:set, c_point, "0"]
+    end
+    
+    # provides access for the point_keys stored in the Class instance variable
+    def point_key(point_key)
+      @_point_keys[point_key]
+    end
+    
+    # provides access to all point_keys for the Class
+    def point_keys
+      @_point_keys
+    end    
+  end
+  
+  module InstanceMethods
+    # Instance method for accessing the cachecataz namespace identifier
+    #
+    # @param [Symbol] point_key name of the cache_space defined on the Class
+    # @param [Hash] scope_hash provides the data for the namespace key
+    # @return [string] namespace key for the cachecataz namespace
+    def cachecataz_key(point_key, scope_hash={})
+      return "cachecataz disabled" if !Cachecataz::Config[:enabled]
+
+      scope_hash = self.attributes if scope_hash == {} && self.respond_to?(:attributes)
+      return self.class.cache_key(point_key, scope_hash)
+    end
+    
+    # Instance method to return a cache_key for the class
+    #
+    # @note method removes any index that is already in the namespace definition as it can't be 2x as unique on the same key
+    #
+    # @example user.cache_key(:ck_name, [:id]) # => "0:ck_name/:id"   
+    #
+    # @param [Symbol] point_key name of the cache_space defined on the Class
+    # @param [Array, []] indexes additional data elements that makeup the key for the instance
+    # @param [Hash, self.attributes] scope_hash provides the data for the namespace key
+    def cache_key(point_key, indexes=[], scope_hash={})
+      cache_key_point = cachecataz_key(point_key, scope_hash)
+      indexes = [indexes] if !indexes.respond_to?(:each)
+      indexes.uniq!
+      indexes.reject!{ |i| self.class.point_key(point_key).include?(i) }
+      return indexes.inject(cache_key_point){|s, n| s << Cachecataz::Config[:index_delim] << self.cachecataz_index_convert(n) }
+    end
+    
+    # Determines the intended index conversion for index passed to cache_key 
+    #
+    # @note if index responds to :call then it will check the arity to determine if it is 1, if so it passes self as the argument
+    #
+    # @param [Object] val the value passed to cache_key index
+    # @return [String] string to append to namespace key
+    def cachecataz_index_convert(val)
+      case
+      when val.kind_of?(Symbol) && self.respond_to?(val)
+        self.send(val).to_s
+      when val.respond_to?(:call)
+        val.arity == 1 ? val.call(self).to_s : val.call.to_s  
+      else
+        val.to_s
+      end
+    end
+    
+    # Instance method to expire a cachecataz namespace
+    #
+    # @param [Symbol] point_key name of the cache_space defined on the Class
+    # @param [Hash, self.attributes] scope_hash provides the data for the namespace key
+    def expire_namespace(point_key, scope_hash={})
+      scope_hash = self.attributes if scope_hash == {} && self.respond_to?(:attributes)
+      self.class.expire_namespace(point_key, scope_hash)
+    end
+    
+    # Instance method to expire all namespaces for an object
+    def expire_all_namespaces(scope_hash={})
+      scope_hash = self.attributes if scope_hash == {} && self.respond_to?(:attributes)
+      self.class.expire_all_namespaces(scope_hash)
+    end
+    
+    # Instance method to reset a namespace, shouldn't really be needed, but avail
+    def cachecataz_namespace_reset(point_key, scope_hash={})
+      scope_hash = self.attributes if scope_hash == {} && self.respond_to?(:attributes)
+      self.class.cachecataz_namespace_reset(point_key, scope_hash)
+    end    
+  end
+end

data/spec/cachecataz_spec.rb

@@ -0,0 +1,152 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe MockModel do
+  describe "disabled" do
+    
+    before(:all) do
+      Cachecataz.enable = false
+    end
+    
+    it "is disabled on initialization for cache_scope :user" do
+      subject.cache_key(:user).should include("cachecataz disabled")
+    end
+    
+    it "is disabled on initialization for cache_scope :user, [:id, :user_id]" do
+      subject.cache_key(:user, [:id, :user_id]).should include("cachecataz disabled")
+    end    
+  end
+  
+  describe "basic namespacing" do
+    subject { MockModel.new }
+    
+    before(:all) do
+      Cachecataz.enable = true
+      Cachecataz.provider = MockCache.new
+    end
+
+    it "returns a namespace key for an empty cache_scope" do
+      subject.cache_key(:empty).should eq("0:empty")
+    end
+    
+    it "returns a namespace key for cache_scope :user" do
+      subject.cache_key(:user).should eq("0:user:#{subject.user_id}")
+    end
+    
+    it "returns a multi namespace key for cache_scope :multi" do
+      subject.cache_key(:multi).should eq("0:multi:#{subject.id}:#{subject.user_id}")
+    end
+
+    it "returns a namespace key with index for and empty cache_scope :empty, :id" do
+      subject.cache_key(:empty, :id).should eq("0:empty/#{subject.id}")
+    end
+
+    it "returns a namespace key with index for cache_scope :user, :id" do
+      subject.cache_key(:user, :id).should eq("0:user:#{subject.user_id}/#{subject.id}")
+    end
+    
+    it "returns a multi namespace key for cache_scope :multi, :assoc_id" do
+      subject.cache_key(:multi, :assoc_id).should eq("0:multi:#{subject.id}:#{subject.user_id}/#{subject.assoc_id}")
+    end
+    
+    it "returns the same value for each key request on single variable non indexed cache_scope :user" do
+      10.times do
+        subject.cache_key(:user).should eq(subject.cache_key(:user))
+      end
+    end
+
+    it "returns the same value for each key request on mutli variable non indexed cache_scope :multi" do
+      10.times do
+        subject.cache_key(:multi).should eq(subject.cache_key(:multi))
+      end
+    end
+
+    it "returns the same value for each key request on single variable indexed cache_scope :user, :id" do
+      10.times do
+        subject.cache_key(:user, :id).should eq(subject.cache_key(:user, :id))
+      end
+    end
+
+    it "returns the same value for each key request on multi variable indexed cache_scope :multi, :assoc_id" do
+      10.times do
+        subject.cache_key(:multi, :assoc_id).should eq(subject.cache_key(:multi, :assoc_id))
+      end
+    end
+    
+    it "expires a namespace key for a single variable cache_scope :user" do
+      subject.expire_namespace(:user)
+      subject.cache_key(:user).should eq("1:user:#{subject.user_id}")
+    end
+
+    it "expires a namespace with index key for a mutli variable cache_scope :multi" do
+      subject.expire_namespace(:multi)
+      subject.cache_key(:multi).should eq("1:multi:#{subject.id}:#{subject.user_id}")
+    end
+    
+    it "expires a namespace key with index for cache_scope :user, :id" do
+      subject.expire_namespace(:user)
+      subject.cache_key(:user, :id).should eq("2:user:#{subject.user_id}/#{subject.id}")
+    end
+    
+    it "expires a multi namespace key with index for cache_scope :multi, :assoc_id" do
+      subject.expire_namespace(:multi)
+      subject.cache_key(:multi, :assoc_id).should eq("2:multi:#{subject.id}:#{subject.user_id}/#{subject.assoc_id}")
+    end
+    
+    describe "namespace delim change" do
+      before(:all) do
+        Cachecataz::Config[:provider].clear # not part of api, just an easy way to clear the mock cache
+        Cachecataz.delim = ["|", "/"]
+      end
+      
+      it "returns a namespace key with index for cache_scope :user, :id" do
+        subject.cache_key(:user, :id).should eq("0|user|#{subject.user_id}/#{subject.id}")
+      end
+      
+      it "returns a multi namespace key for cache_scope :multi, :assoc_id" do
+        subject.cache_key(:multi, :assoc_id).should eq("0|multi|#{subject.id}|#{subject.user_id}/#{subject.assoc_id}")
+      end        
+    end
+    
+    describe "index delim change" do
+      before(:all) do
+        Cachecataz::Config[:provider].clear  # not part of api, just an easy way to clear the mock cache
+        Cachecataz.delim = [":", "|"]
+      end
+      
+      it "returns a namespace key with index for cache_scope :user, :id" do
+        subject.cache_key(:user, :id).should eq("0:user:#{subject.user_id}|#{subject.id}")
+      end
+      
+      it "returns a multi namespace key for cache_scope :multi, :assoc_id" do
+        subject.cache_key(:multi, :assoc_id).should eq("0:multi:#{subject.id}:#{subject.user_id}|#{subject.assoc_id}")
+      end        
+    end
+    
+    describe "redefine api respond_to :call" do
+      before(:all) do
+        Cachecataz::Config[:provider].clear
+        Cachecataz.delim = [":", "/"]
+        Cachecataz.api = {:get => lambda{ |*args| Cachecataz::Config[:provider].all(:read, *args) }, 
+                          :set => lambda{ |*args| Cachecataz::Config[:provider].all(:write, *args) }, 
+                          :incr => lambda{ |*args| Cachecataz::Config[:provider].all(:increment, *args) }, 
+                          :exist? => lambda{ |*args| Cachecataz::Config[:provider].all(:exist?, *args) }}
+      end
+  
+      it "returns a namespace key for an empty cache_scope" do
+        subject.cache_key(:empty).should eq("0:empty")
+      end
+      
+      it "returns a namespace key for cache_scope :user" do
+        subject.cache_key(:user).should eq("0:user:#{subject.user_id}")
+      end
+      
+      it "returns a multi namespace key for cache_scope :multi" do
+        subject.cache_key(:multi).should eq("0:multi:#{subject.id}:#{subject.user_id}")
+      end
+
+      it "returns a namespace key with index for and empty cache_scope :empty, :id" do
+        subject.cache_key(:empty, :id).should eq("0:empty/#{subject.id}")
+      end
+    end    
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'rspec'
+require 'cachecataz'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/spec/support/mock_cache.rb

@@ -0,0 +1,29 @@
+class MockCache
+  def initialize
+    @cache = {}
+  end
+  
+  def read(key)
+    @cache[key].to_s
+  end
+  
+  def write(key, val)
+    @cache[key] = val.to_s
+  end
+  
+  def increment(key)
+    @cache[key] = @cache[key].to_i + 1
+  end
+  
+  def exist?(key)
+    !!@cache[key]
+  end
+  
+  def all(action, *args)
+    self.send(action, *args)
+  end
+  
+  def clear
+    @cache = {}
+  end
+end  

data/spec/support/mock_model.rb

@@ -0,0 +1,30 @@
+class MockModel
+  include Cachecataz
+  
+  cache_scope :empty
+  cache_scope :test, :id
+  cache_scope :user, :user_id
+  cache_scope :multi, [:id, :user_id]
+
+  def initialize
+    @id = "1"
+    @user_id = "2"
+    @assoc_id = "3"
+  end
+  
+  def id
+    @id
+  end
+  
+  def user_id
+    @user_id
+  end
+  
+  def assoc_id
+    @assoc_id
+  end
+  
+  def attributes
+    {:user_id => @user_id, :id => @id, "assoc_id" => @assoc_id, "extra" => "attributes", "not" => "important", :but => :present}
+  end
+end

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification 
+name: cachecataz
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 0
+  version: 0.1.0
+platform: ruby
+authors: 
+- Brandon Dewitt
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-03-14 00:00:00 -04:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 3
+        - 0
+        version: 2.3.0
+  requirement: *id001
+  prerelease: false
+  type: :development
+  name: rspec
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 1
+        - 0
+        - 0
+        version: 1.0.0
+  requirement: *id002
+  prerelease: false
+  type: :development
+  name: bundler
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 1
+        - 5
+        - 2
+        version: 1.5.2
+  requirement: *id003
+  prerelease: false
+  type: :development
+  name: jeweler
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  requirement: *id004
+  prerelease: false
+  type: :development
+  name: rcov
+- !ruby/object:Gem::Dependency 
+  version_requirements: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        hash: 7
+        segments: 
+        - 2
+        version: "2"
+  requirement: *id005
+  prerelease: false
+  type: :development
+  name: rspec
+description: Cachecataz is for namespace expiry in a cache where the cache provider does not enable namespace based expiry (like memcached!)
+email: brandon+cachecataz@myjibe.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE.txt
+- README.rdoc
+files: 
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/cachecataz.rb
+- spec/cachecataz_spec.rb
+- spec/spec_helper.rb
+- spec/support/mock_cache.rb
+- spec/support/mock_model.rb
+has_rdoc: true
+homepage: http://github.com/bdewitt/cachecataz
+licenses: 
+- MIT
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+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: cache namespace expiry gem for cache servers that do not have namespace expiry
+test_files: 
+- spec/cachecataz_spec.rb
+- spec/spec_helper.rb
+- spec/support/mock_cache.rb
+- spec/support/mock_model.rb