cachy 0.1.2

data/README.markdown

@@ -0,0 +1,120 @@
+Caching library to simplify and organize caching.
+
+ - I18n (seperate caches by locale / expires all locales)
+ - Generation based (expire all caches of one type)
+ - Simultanouse caching (multiple processes trying to write same cache at once)
+ - Dependent caches (x caches result of cache z+y -> z changes -> x changes)
+ - Hashed keys (optional -> short/unreadable)
+ - Global cache_version (expire everything Cachy cached)
+ - ...
+ - works out of the box with Rails
+ - works with pure Memcache and [Moneta](http://github.com/wycats/moneta/tree/master)(-> Tokyo Cabinet / CouchDB / S3 / Berkeley DB / DataMapper / Memory store)
+
+Install
+=======
+As Gem: ` sudo gem install cachy `
+Or as Rails plugin: ` script/plugins install git://github.com/grosser/cachy.git `
+
+
+Usage
+=====
+###Cachy.cache
+    result = Cachy.cache(:a_key){ expensive() }
+    result = Cachy.cache(:a_key, :expires_in => 1.minute){ expensive() }
+    result = Cachy.cache(:a_key, 'something else', Date.today.day){ expensive() }
+
+####Cache expensive operation that is run many times by many processes
+Example scenario: at application Startup 20 processes try to set the same cache -> 20 heavy database requests -> database timeout -> cache still empty -> ... -> death
+
+    # 19 Processes get [], 1 makes the request -- when cached all get the same result
+    result = Cachy.cache(:a_key, :while_running=>[]){ block_db_for_5_seconds }
+
+
+####Seperate version for each key
+Expire all all caches of one kind when e.g. codebase has been updated
+
+    100.times{ Cachy.cache(:a_key, rand(100000) ){ expensive() } }
+    Cachy.increment_key(:a_key) --> everything expired
+
+
+####Uses I18n.locale if available
+    Cachy.cache(:a_key){ 'English' }
+    I18n.locale = :de
+    Cachy.cache(:a_key){ 'German' } != 'English'
+
+####Explicitly not use I18n.locale
+    Cachy.cache(:a_key, :witout_locale=>true){ 'English' }
+    I18n.locale = :de
+    Cachy.cache(:a_key, :witout_locale=>true){ 'German' } == 'English'
+
+####Caching results of other caches
+When inner cache is expired outer cache would normally still shows old results.  
+--> expire outer cache when inner cache is expired.
+
+    a = Cachy.cache(:a, :expires_in=>1.day){ expensive() }
+    b = Cachy.cache(:b, :expires_in=>1.week){ expensive_2() }
+    Cachy.cache(:surrounding, :expires_in=>5.hours, :keys=>[:a, :b]){ a + b * c }
+    Cachy.increment_key(:b) -->  expires :b and :surrounding
+
+####Hashing keys
+In case they get to long for your caching backend, makes them short but unreadable.
+
+    Cachy.hash_keys = true  # global
+    Cachy.cache(:a_key, :hash_key=>true){ expensive } # per call
+
+#### Uses .cache_key when available
+E.g. ActiveRecord objects are stored in the key with their updated_at timestamp.  
+When they are updated the cache is automatically expired.
+
+    Cachy.cache(:my_key, User.first){ expensive }
+
+#### Uses CACHE_VERSION if defined
+Use a global `CACHE_VERSION=1` so that all caches can be expired when something big changes.
+The cache server does not need to be restarted and session data(Rails) is saved.
+
+
+#### Does not cache nil
+If you want to cache a falsy result, use false (same goes for :while_running)
+    Cachy.cache(:x){ expensive || false }
+    Cachy.cache(:x, :while_running=>false){ expensive }
+
+###Cachy.expire / .expire_view
+Expires all locales of a key
+    Cachy.locales = [:de, :en] # by default filled with I18n.available_locales
+    Cachy.expire(:my_key) -> expires for :de, :en and no-locale
+
+    #expire "views/#{key}" (counterpart for Rails-view-caching)
+    Cachy.expire_view(:my_key)
+    Cachy.expire(:my_key, :prefix=>'views/')
+
+
+###Cachy.key
+Use to cache e.g. Erb output
+    <% cache Cachy.key(:a_key), :expires_in=>1.hour do %>
+      More html ...
+    <% end %>
+
+
+###Cachy.cache_store
+No ActionController::Base.cache_store ?  
+Give me something that responds to read/write(Rails style) or []/store([Moneta](http://github.com/wycats/moneta/tree/master)) or get/set(Memcached)
+    Cachy.cache_store = some_cache
+
+
+###Cachy.locales
+No I18n.available_locales ?
+    Cachy.locales = [:de, :en, :fr]
+
+TODO
+====
+ - optionally store dependent keys (:keys=>xxx), so that they can be setup up once and dont need to be remembered
+
+Authors
+=======
+
+###Contributors
+ - [mindreframer](http://www.simplewebapp.de/roman)
+
+[Michael Grosser](http://pragmatig.wordpress.com)  
+grosser.michael@gmail.com  
+Hereby placed under public domain, do what you want, just do not hold me accountable...

data/Rakefile

@@ -0,0 +1,30 @@
+desc "Run all specs in spec directory"
+task :default do
+  options = "--colour --format progress --loadby --reverse"
+  files = FileList['spec/**/*_spec.rb']
+  system("spec #{options} #{files}")
+end
+
+
+begin
+  require 'jeweler'
+  project_name = 'cachy'
+  Jeweler::Tasks.new do |gem|
+    gem.name = project_name
+    gem.summary = "Caching library for projects that have many processes or many caches"
+    gem.email = "grosser.michael@gmail.com"
+    gem.homepage = "http://github.com/grosser/#{project_name}"
+    gem.authors = ["Michael Grosser"]
+    gem.rubyforge_project = project_name
+  end
+
+  # fake task so that rubyforge:release works
+  task :rdoc do
+    `mkdir rdoc`
+    `echo documentation is at http://github.com/grosser/#{project_name} > rdoc/README.rdoc`
+  end
+
+  Jeweler::RubyforgeTasks.new
+rescue LoadError
+  puts "Jeweler, or one of its dependencies, is not available. Install it with: sudo gem install technicalpickles-jeweler -s http://gems.github.com"
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.2

data/cachy.gemspec

@@ -0,0 +1,55 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE
+# Instead, edit Jeweler::Tasks in Rakefile, and run `rake gemspec`
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{cachy}
+  s.version = "0.1.2"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Michael Grosser"]
+  s.date = %q{2009-10-16}
+  s.email = %q{grosser.michael@gmail.com}
+  s.extra_rdoc_files = [
+    "README.markdown"
+  ]
+  s.files = [
+    "README.markdown",
+     "Rakefile",
+     "VERSION",
+     "cachy.gemspec",
+     "lib/cachy.rb",
+     "lib/cachy/memcached_wrapper.rb",
+     "lib/cachy/moneta_wrapper.rb",
+     "lib/cachy/wrapper.rb",
+     "spec/cachy/memcached_wrapper_spec.rb",
+     "spec/cachy/moneta_wrapper_spec.rb",
+     "spec/cachy_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/test_cache.rb"
+  ]
+  s.homepage = %q{http://github.com/grosser/cachy}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{cachy}
+  s.rubygems_version = %q{1.3.5}
+  s.summary = %q{Caching library for projects that have many processes or many caches}
+  s.test_files = [
+    "spec/test_cache.rb",
+     "spec/cachy/memcached_wrapper_spec.rb",
+     "spec/cachy/moneta_wrapper_spec.rb",
+     "spec/spec_helper.rb",
+     "spec/cachy_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end

data/lib/cachy.rb

@@ -0,0 +1,194 @@
+class Cachy
+  WHILE_RUNNING_TMEOUT = 5*60 #seconds
+  KEY_VERSION_TIMEOUT = 30 #seconds
+
+  # Cache the result of a block
+  #
+  # Cachy.cache(:my_key){ expensive() }
+  # Cachy.cache(:my_key, :expires_in=>1.hour){ expensive() }
+  # Cachy.cache(:my_key, :keys=>[:dependent_key]){ expensive() }
+  # Cachy.cache(:my_key, :without_locale=>true){ expensive() }
+  # Cachy.cache(:my_key, :hash_key=>true){ expensive() }
+  def self.cache(*args)
+    key = key(*args)
+    options = extract_options!(args)
+
+    # Cached result?
+    result = cache_store.read(key)
+    return result unless result == nil
+
+    # Calculate result!
+    set_while_running(key, options)
+
+    result = yield
+    cache_store.write key, result, options
+    result
+  end
+
+  # Constructs a cache-key (first argument must be a String/Symbol)
+  #
+  # Cachy.key :my_key
+  # Cachy.key :my_key, User.first, :locale=>:de
+  # Cachy.key :my_key, User.first, :without_locale=>true, :hash_key=>true
+  def self.key(*args)
+    options = extract_options!(args)
+    ensure_valid_keys options
+
+    key = (args + meta_key_parts(args.first, options)).compact.map do |part|
+      if part.respond_to? :cache_key
+        part.cache_key
+      else
+        part
+      end
+    end * "_"
+
+    key = (options[:hash_key] || hash_keys) ? hash(key) : key
+    options[:prefix].to_s + key + options[:suffix].to_s
+  end
+
+  # Expire all possible locales of a cache, use the same arguments as with cache
+  #
+  # Cachy.expire(:my_key, User.first)
+  # Cachy.expire(:my_key, User.first, :keys=>[:dependent_keys])
+  # Cachy.expire(:my_key, :prefix=>'views/')
+  def self.expire(*args)
+    options = extract_options!(args)
+
+    (locales+[false]).each do |locale|
+      without_locale = (locale==false)
+      args_with_locale = args + [options.merge(:locale=>locale, :without_locale=>without_locale)]
+      cache_store.delete key(*args_with_locale)
+    end
+  end
+
+  def self.expire_view(*args)
+    options = extract_options!(args)
+    args = args + [options.merge(:prefix=>'views/')]
+    expire(*args)
+  end
+
+  # Fetch key_versions from cache every KEY_VERSION_TIMEOUT seconds,
+  # otherwise every .key call would result in an cache request
+  @@key_versions = {:versions=>{}, :last_set=>0}
+  def self.key_versions
+    if key_versions_expired?
+      versions = cache_store.read("cachy_key_versions") || {}
+      @@key_versions = {:versions=>versions, :last_set=>Time.now.to_i}
+    end
+    @@key_versions[:versions]
+  end
+
+  def self.key_versions=(data)
+    @@key_versions[:last_set] = 0 #expire current key
+    cache_store.write("cachy_key_versions", data)
+  end
+
+  # Expires all caches that use this key
+  def self.increment_key(key)
+    key = key.to_sym
+    version = key_versions[key] || 0
+    version += 1
+    self.key_versions = key_versions.merge(key => version)
+    version
+  end
+
+  class << self
+    attr_accessor :hash_keys
+  end
+  
+  # Wrap non ActiveSupport style cache stores,
+  # to get the same interface for all
+  def self.cache_store=(x)
+    if x.respond_to? :read and x.respond_to? :write
+      @cache_store=x
+    elsif x.respond_to? "[]" and x.respond_to? :set
+      require 'cachy/memcached_wrapper'
+      @cache_store = MemcachedWrapper.new(x)
+    elsif x.respond_to? "[]" and x.respond_to? :store
+      require 'cachy/moneta_wrapper'
+      @cache_store = MonetaWrapper.new(x)
+    else
+      raise "This cache_store type is not usable for Cachy!"
+    end
+  end
+
+  def self.cache_store
+    @cache_store || raise("Use: Cachy.cache_store = your_cache_store")
+  end
+
+  self.cache_store = ActionController::Base.cache_store if defined? ActionController::Base
+
+  # locales
+  class << self
+    attr_accessor :locales
+  end
+
+  self.locales = if defined?(I18n) and I18n.respond_to?(:available_locales)
+    I18n.available_locales
+  else
+    []
+  end
+
+  private
+
+  # Do we need to fetch fresh key_versions from cache ?
+  def self.key_versions_expired?
+    key_versions_timeout = Time.now.to_i - KEY_VERSION_TIMEOUT
+    @@key_versions[:last_set] < key_versions_timeout
+  end
+
+  # Temorarily store something else in the cache,
+  # so that a often-called and slow cache-block is not run by
+  # multiple processes in parallel
+  def self.set_while_running(key, options)
+    return unless options.key? :while_running
+    warn "You cannot set while_running to nil" if options[:while_running] == nil
+    cache_store.write key, options[:while_running], :expires_in=>WHILE_RUNNING_TMEOUT
+  end
+
+  def self.meta_key_parts(key, options)
+    unless [String, Symbol].include?(key.class)
+      raise ":key must be first argument of Cachy call"
+    end
+
+    parts = []
+    parts << "v#{key_version_for(key)}"
+    parts << global_cache_version
+    parts << (options[:locale] || locale) unless options[:without_locale]
+
+    keys = [*options[:keys]].compact # [*x] == .to_a without warnings
+    parts += keys.map{|k| "#{k}v#{key_version_for(k)}" }
+    parts
+  end
+
+  def self.key_version_for(key)
+    key = key.to_sym
+    key_versions[key] || increment_key(key)
+  end
+
+  def self.ensure_valid_keys(options)
+    invalid = options.keys - [:keys, :expires_in, :without_locale, :locale, :while_running, :hash_key, :prefix, :suffix]
+    raise "unknown keys #{invalid.inspect}" unless invalid.empty?
+  end
+
+  def self.hash(string)
+    require "digest/md5"
+    Digest::MD5.hexdigest(string)
+  end
+
+  def self.global_cache_version
+    defined?(CACHE_VERSION) ? CACHE_VERSION : nil
+  end
+
+  def self.locale
+    (defined?(I18n) and I18n.respond_to?(:locale)) ? I18n.locale : nil
+  end
+
+  def self.extract_options!(args)
+    if args.last.is_a? Hash
+      args.pop
+    else
+      {}
+    end
+  end
+end

data/lib/cachy/memcached_wrapper.rb

@@ -0,0 +1,8 @@
+require 'cachy/wrapper'
+
+# Wrapper for Memcached
+class Cachy::MemcachedWrapper < Cachy::Wrapper
+  def write(key, result, options={})
+    @wrapped.set(key, result, options[:expires_in].to_i)
+  end
+end

data/lib/cachy/moneta_wrapper.rb

@@ -0,0 +1,8 @@
+require 'cachy/wrapper'
+
+# Wrapper for Moneta http://github.com/wycats/moneta/tree/master
+class Cachy::MonetaWrapper < Cachy::Wrapper
+  def write(key, result, options={})
+    @wrapped.store(key, result, options)
+  end
+end

data/lib/cachy/wrapper.rb

@@ -0,0 +1,17 @@
+class Cachy::Wrapper
+  def initialize(wrapped)
+    @wrapped = wrapped
+  end
+
+  def read(key)
+    @wrapped[key]
+  end
+
+  def method_missing(name, args)
+    @wrapped.send(name, *args)
+  end
+
+  def respond_to?(x)
+    super(x) || @wrapped.respond_to?(x)
+  end
+end

data/spec/cachy/memcached_wrapper_spec.rb

@@ -0,0 +1,63 @@
+require 'spec/spec_helper'
+
+class TestMemcached
+  def initialize
+    @wrapped = {}
+  end
+
+  def set(key, object, ttl = nil)
+    raise 'nope!' if ttl.is_a? Hash or (ttl and not ttl.is_a? Numeric)
+    @wrapped[key] = object
+  end
+
+  def get(key)
+    @wrapped[key]
+  end
+
+  def [](x)
+    @wrapped[x]
+  end
+
+  def clear
+    @wrapped.clear
+  end
+
+  def delete(key)
+    @wrapped.delete(key)
+  end
+end
+
+describe "Cachy::MemcachedWrapper" do
+  before :all do
+    @cache = TestMemcached.new
+    Cachy.cache_store = @cache
+  end
+
+  before do
+    @cache.clear
+  end
+
+  it "is wrapped" do
+    Cachy.cache_store.class.should == Cachy::MemcachedWrapper
+  end
+
+  it "can cache" do
+    Cachy.cache(:x){ 'SUCCESS' }
+    Cachy.cache(:x){ 'FAIL' }.should == 'SUCCESS'
+  end
+
+  it "can cache without expires" do
+    @cache.should_receive(:set).with('x_v1', 'SUCCESS', 0)
+    Cachy.cache(:x){ 'SUCCESS' }
+  end
+
+  it "can cache with expires" do
+    @cache.should_receive(:set).with('x_v1', 'SUCCESS', 1)
+    Cachy.cache(:x, :expires_in=>1){ 'SUCCESS' }
+  end
+
+  it "can expire" do
+    @cache.should_receive(:delete).with('x_v1')
+    Cachy.expire(:x)
+  end
+end

data/spec/cachy/moneta_wrapper_spec.rb

@@ -0,0 +1,59 @@
+require 'spec/spec_helper'
+
+class TestMoneta
+  def initialize
+    @wrapped = {}
+  end
+
+  def store(key, object, options={})
+    raise 'nope!' if options[:expires_in] and not options[:expires_in].is_a? Numeric
+    @wrapped[key] = object
+  end
+
+  def [](x)
+    @wrapped[x]
+  end
+
+  def clear
+    @wrapped.clear
+  end
+
+  def delete(key)
+    @wrapped.delete(key)
+  end
+end
+
+describe "Cachy::MonetaWrapper" do
+  before :all do
+    @cache = TestMoneta.new
+    Cachy.cache_store = @cache
+  end
+
+  before do
+    @cache.clear
+  end
+
+  it "is wrapped" do
+    Cachy.cache_store.class.should == Cachy::MonetaWrapper
+  end
+
+  it "can cache" do
+    Cachy.cache(:x){ 'SUCCESS' }
+    Cachy.cache(:x){ 'FAIL' }.should == 'SUCCESS'
+  end
+
+  it "can cache without expires" do
+    @cache.should_receive(:store).with('x_v1', 'SUCCESS', {})
+    Cachy.cache(:x){ 'SUCCESS' }
+  end
+
+  it "can cache with expires" do
+    @cache.should_receive(:store).with('x_v1', 'SUCCESS', :expires_in=>1)
+    Cachy.cache(:x, :expires_in=>1){ 'SUCCESS' }
+  end
+
+  it "can expire" do
+    @cache.should_receive(:delete).with('x_v1')
+    Cachy.expire(:x)
+  end
+end

data/spec/cachy_spec.rb

@@ -0,0 +1,247 @@
+require 'spec/spec_helper'
+
+TEST_CACHE = TestCache.new
+
+describe Cachy do
+  before :all do
+    Cachy.cache_store = TEST_CACHE
+  end
+
+  before do
+    TEST_CACHE.clear
+  end
+  
+  describe :cache do
+    it "caches" do
+      Cachy.cache(:my_key){ "X" }.should == "X"
+      Cachy.cache(:my_key){ "ABC" }.should == "X"
+    end
+    
+    it "expires" do
+      Cachy.cache(:his_key, :expires_in=> -100){ 'X' }.should == 'X'
+      Cachy.cache(:his_key, :expires_in=> -100){ 'X' }.should == 'X'
+    end
+    
+    it "sets cache to intermediate value while running expensive query" do
+      Cachy.cache(:my_key, :while_running=>'A') do
+        Cachy.cache(:my_key){ 'X' }.should == 'A'
+      end
+    end
+
+    it "can set while_running to false" do
+      Cachy.cache(:my_key, :while_running=>false) do
+        Cachy.cache(:my_key){ 'X' }.should == false
+      end
+    end
+
+    it "can not set while_running to nil" do
+      Cachy.should_receive(:warn)
+      Cachy.cache(:my_key, :while_running=>nil) do
+        Cachy.cache(:my_key){ 'X' }.should == "X"
+      end
+    end
+
+    it "can cache false" do
+      Cachy.cache(:x){ false }.should == false
+      Cachy.cache(:x){ true }.should == false
+    end
+
+    it "does not cache nil" do
+      Cachy.cache(:x){ nil }.should == nil
+      Cachy.cache(:x){ true }.should == true
+    end
+  end
+
+  describe :expire do
+    it "expires the cache for all languages" do
+      Cachy.cache(:my_key){ "without_locale" }
+
+      locales = [:de, :en, :fr]
+      locales.each do |l|
+        Cachy.stub!(:locale).and_return l
+        Cachy.cache(:my_key){ l }
+      end
+
+      TEST_CACHE.keys.select{|k| k=~ /my_key/}.size.should == 4
+      Cachy.stub!(:locales).and_return locales
+      Cachy.expire(:my_key)
+      TEST_CACHE.keys.select{|k| k=~ /my_key/}.size.should == 0
+    end
+
+    it "does not expire other keys" do
+      Cachy.cache(:another_key){ 'X' }
+      Cachy.cache(:my_key){ 'X' }
+      Cachy.cache(:yet_another_key){ 'X' }
+      Cachy.expire :my_key
+      TEST_CACHE.keys.should include("another_key_v1")
+      TEST_CACHE.keys.should include("yet_another_key_v1")
+    end
+
+    it "expires the cache when no available_locales are set" do
+      Cachy.cache(:another_key){ "X" }
+      Cachy.cache(:my_key){ "X" }
+
+      TEST_CACHE.keys.select{|k| k=~ /my_key/}.size.should == 1
+      Cachy.expire(:my_key)
+      TEST_CACHE.keys.select{|k| k=~ /my_key/}.size.should == 0
+    end
+
+    it "expires the cache with prefix" do
+      key = 'views/my_key_v1'
+      TEST_CACHE.write(key, 'x')
+      TEST_CACHE.read(key).should_not == nil
+      Cachy.expire(:my_key, :prefix=>'views/')
+      TEST_CACHE.read(key).should == nil
+    end
+  end
+
+  describe :expire_view do
+    it "expires the cache with prefix" do
+      key = 'views/my_key_v1'
+      TEST_CACHE.write(key, 'x')
+      TEST_CACHE.read(key).should_not == nil
+      Cachy.expire_view(:my_key)
+      TEST_CACHE.read(key).should == nil
+    end
+  end
+
+  describe :key do
+    it "builds based on cache_key" do
+      user = mock(:cache_key=>'XXX',:something_else=>'YYY')
+      Cachy.key(:my_key, 1, user, "abc").should == 'my_key_1_XXX_abc_v1'
+    end
+
+    it "adds current_language" do
+      Cachy.stub!(:locale).and_return :de
+      Cachy.key(:x).should == "x_v1_de"
+    end
+
+    it "raises on unknown options" do
+      lambda{Cachy.key(:x, :asdasd=>'asd')}.should raise_error
+    end
+
+    it "gets the locale from I18n" do
+      module I18n
+        def self.locale
+          :de
+        end
+      end
+      key = Cachy.key(:x)
+      Object.send :remove_const, :I18n #cleanup
+      key.should == "x_v1_de"
+    end
+
+    describe "with :hash_key" do
+      before do
+        @hash = '3b2b8f418849bc73071375529f8515be'
+      end
+
+      after do
+        Cachy.hash_keys = false
+      end
+
+      it "hashed the key to a stable value" do
+        Cachy.key(:xxx, :hash_key=>true).should == @hash
+      end
+
+      it "changes when key changes" do
+        Cachy.key(:xxx, :hash_key=>true).should_not == Cachy.key(:yyy, :hash_key=>true)
+      end
+
+      it "changes when arguments change" do
+        Cachy.key(:xxx, :hash_key=>true).should_not == Cachy.key(:xxx, 1, :hash_key=>true)
+      end
+
+      it "can be triggered by Cachy.hash_keys" do
+        Cachy.hash_keys = true
+        Cachy.key(:xxx).should == @hash
+      end
+    end
+
+    describe "with :keys" do
+      it "is stable" do
+        Cachy.key(:x, :keys=>'asd').should == Cachy.key(:x, :keys=>'asd')
+      end
+
+      it "changes when dependent key changes" do
+        lambda{
+          Cachy.increment_key('asd')
+        }.should change{Cachy.key(:x, :keys=>'asd')}
+      end
+
+      it "is different for different keys" do
+        Cachy.key(:x, :keys=>'xxx').should_not == Cachy.key(:x, :keys=>'yyy')
+      end
+    end
+
+    describe 'with :without_locale' do
+      it "is stable with same locale" do
+        Cachy.stub!(:locale).and_return :de
+        Cachy.key(:x, :without_locale=>true).should == Cachy.key(:x, :without_locale=>true)
+      end
+
+      it "is stable with different locales" do
+        Cachy.stub!(:locale).and_return :de
+        de_key = Cachy.key(:x, :without_locale=>true)
+        Cachy.stub!(:locale).and_return :en
+        Cachy.key(:x, :without_locale=>true).should == de_key
+      end
+    end
+
+    describe 'with :locale' do
+      it "changes the default key" do
+        Cachy.key(:x, :locale=>:de).should_not == Cachy.key(:x)
+      end
+
+      it "is a different key for different locales" do
+        Cachy.key(:x, :locale=>:de).should_not == Cachy.key(:x, :locale=>:en)
+      end
+
+      it "is the same key for the same locales" do
+        Cachy.key(:x, :locale=>:de).should == Cachy.key(:x, :locale=>:de)
+      end
+    end
+  end
+
+  describe :key_versions do
+    before do
+      Cachy.key_versions = {}
+      Cachy.key_versions.should == {}
+    end
+
+    it "adds a key when cache is called the first time" do
+      Cachy.cache(:xxx){1}
+      Cachy.key_versions[:xxx].should == 1
+    end
+
+    it "adds a string key as symbol" do
+      Cachy.cache('yyy'){1}
+      Cachy.key_versions[:yyy].should == 1
+    end
+
+    it "does not overwrite a key when it already exists" do
+      Cachy.key_versions = {:xxx => 3}
+      Cachy.cache(:xxx){1}
+      Cachy.cache(:xxx){1}
+      Cachy.key_versions[:xxx].should == 3
+    end
+
+    it "reloads when keys have expired" do
+      Cachy.send :class_variable_set, "@@key_versions", {:versions=>{:xx=>2}, :last_set=>(Time.now.to_i - 60)}
+      TEST_CACHE.write 'cachy_key_versions', {:xx=>1}
+      Cachy.key_versions.should == {:xx=>1}
+    end
+
+    it "does not reload when keys have not expired" do
+      Cachy.send :class_variable_set, "@@key_versions", {:versions=>{:xx=>2}, :last_set=>Time.now.to_i}
+      TEST_CACHE.write 'cachy_key_versions', {:xx=>1}
+      Cachy.key_versions.should == {:xx=>2}
+    end
+
+    it "expires when key_versions is set" do
+      Cachy.send :class_variable_set, "@@key_versions", {:versions=>{:xx=>2}, :last_set=>Time.now.to_i}
+      Cachy.key_versions = {:xx=>1}
+      Cachy.key_versions[:xx].should == 1
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+# ---- requirements
+require 'spec/test_cache'
+$LOAD_PATH << File.expand_path("../lib", File.dirname(__FILE__))
+
+require 'cachy'

data/spec/test_cache.rb

@@ -0,0 +1,25 @@
+class TestCache
+  def initialize
+    @data = {}
+  end
+
+  def read(name)
+    @data[name]
+  end
+
+  def write(name, value, options = nil)
+    @data[name] = value.freeze
+  end
+
+  def delete(name, options = nil)
+    @data.delete(name)
+  end
+
+  def clear
+    @data.clear
+  end
+
+  def keys
+    @data.keys
+  end
+end

metadata

@@ -0,0 +1,71 @@
+--- !ruby/object:Gem::Specification 
+name: cachy
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- Michael Grosser
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-10-16 00:00:00 +02:00
+default_executable: 
+dependencies: []
+
+description: 
+email: grosser.michael@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.markdown
+files: 
+- README.markdown
+- Rakefile
+- VERSION
+- cachy.gemspec
+- lib/cachy.rb
+- lib/cachy/memcached_wrapper.rb
+- lib/cachy/moneta_wrapper.rb
+- lib/cachy/wrapper.rb
+- spec/cachy/memcached_wrapper_spec.rb
+- spec/cachy/moneta_wrapper_spec.rb
+- spec/cachy_spec.rb
+- spec/spec_helper.rb
+- spec/test_cache.rb
+has_rdoc: true
+homepage: http://github.com/grosser/cachy
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: cachy
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: Caching library for projects that have many processes or many caches
+test_files: 
+- spec/test_cache.rb
+- spec/cachy/memcached_wrapper_spec.rb
+- spec/cachy/moneta_wrapper_spec.rb
+- spec/spec_helper.rb
+- spec/cachy_spec.rb