cachy 0.3.1 → 0.4.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d154547cc7dcbf3e251e975ec0ccfcc19edc41ff
+  data.tar.gz: 7f14b01d7247b0e8c32e06956673345eb614dea1
+SHA512:
+  metadata.gz: e7d338aa171c655806b9030383c917e0a87c3b2ce88ad8c724663a69681af7cc30d103c08a7ecc099fcd6d83f74965b05a61b080883086bd2e77a58646780b5e
+  data.tar.gz: 32ffcf0aa8176344a1c5fe3db890cbf01d83eea63a95e5f175ed6e15b9b726d1fc0d8a204a4d8cc29d74ebe5b6b44b42739f346d177895442d66e998ba30250b

checksums.yaml.gz.sig

@@ -0,0 +1,2 @@
+��QlB�Bh2*�����U�d^L�i�*0y�Cu	�43Dw͉y��rN�����u
+uu��;z�
�N?�ن�����؀]$C�!��S'�B�|Ml���_�„�R�6�Ʒ$����աb[�S~�\��W���~'
������������4��9ZN�هgg>o�tf�����Z��#�"����	�C��@�#w0�w�9���m�w

data/lib/cachy.rb

@@ -159,10 +159,10 @@ module Cachy
     elsif cache.class.to_s == 'Redis'
       require 'cachy/redis_wrapper'
       RedisWrapper.new(cache)
-    elsif cache.respond_to? "[]" and cache.respond_to? :set
+    elsif cache.respond_to? :get and cache.respond_to? :set
       require 'cachy/memcached_wrapper'
       MemcachedWrapper.new(cache)
-    elsif cache.respond_to? "[]" and cache.respond_to? :store
+    elsif cache.respond_to? :[] and cache.respond_to? :store
       require 'cachy/moneta_wrapper'
       MonetaWrapper.new(cache)
     else

data/lib/cachy/memcached_wrapper.rb

@@ -1,6 +1,10 @@
 require 'cachy/wrapper'
 
 class Cachy::MemcachedWrapper < Cachy::Wrapper
+  def read(key)
+    @wrapped.get(key)
+  end
+
   def write(key, result, options={})
     @wrapped.set(key, result, options[:expires_in].to_i)
   end

data/lib/cachy/version.rb

@@ -1,3 +1,3 @@
 module Cachy
-  Version = VERSION = '0.3.1'
+  Version = VERSION = '0.4.0'
 end

metadata

@@ -1,44 +1,56 @@
 --- !ruby/object:Gem::Specification
 name: cachy
 version: !ruby/object:Gem::Version
-  prerelease: 
-  version: 0.3.1
+  version: 0.4.0
 platform: ruby
 authors:
 - Michael Grosser
 autorequire: 
 bindir: bin
-cert_chain: []
-date: 2012-12-23 00:00:00.000000000 Z
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIDMjCCAhqgAwIBAgIBADANBgkqhkiG9w0BAQUFADA/MRAwDgYDVQQDDAdtaWNo
+  YWVsMRcwFQYKCZImiZPyLGQBGRYHZ3Jvc3NlcjESMBAGCgmSJomT8ixkARkWAml0
+  MB4XDTEzMDIwMzE4MTMxMVoXDTE0MDIwMzE4MTMxMVowPzEQMA4GA1UEAwwHbWlj
+  aGFlbDEXMBUGCgmSJomT8ixkARkWB2dyb3NzZXIxEjAQBgoJkiaJk/IsZAEZFgJp
+  dDCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMorXo/hgbUq97+kII9H
+  MsQcLdC/7wQ1ZP2OshVHPkeP0qH8MBHGg6eYisOX2ubNagF9YTCZWnhrdKrwpLOO
+  cPLaZbjUjljJ3cQR3B8Yn1veV5IhG86QseTBjymzJWsLpqJ1UZGpfB9tXcsFtuxO
+  6vHvcIHdzvc/OUkICttLbH+1qb6rsHUceqh+JrH4GrsJ5H4hAfIdyS2XMK7YRKbh
+  h+IBu6dFWJJByzFsYmV1PDXln3UBmgAt65cmCu4qPfThioCGDzbSJrGDGLmw/pFX
+  FPpVCm1zgYSb1v6Qnf3cgXa2f2wYGm17+zAVyIDpwryFru9yF/jJxE38z/DRsd9R
+  /88CAwEAAaM5MDcwCQYDVR0TBAIwADAdBgNVHQ4EFgQUsiNnXHtKeMYYcr4yJVmQ
+  WONL+IwwCwYDVR0PBAQDAgSwMA0GCSqGSIb3DQEBBQUAA4IBAQAlyN7kKo/NQCQ0
+  AOzZLZ3WAePvStkCFIJ53tsv5Kyo4pMAllv+BgPzzBt7qi605mFSL6zBd9uLou+W
+  Co3s48p1dy7CjjAfVQdmVNHF3MwXtfC2OEyvSQPi4xKR8iba8wa3xp9LVo1PuLpw
+  /6DsrChWw74HfsJN6qJOK684hJeT8lBYAUfiC3wD0owoPSg+XtyAAddisR+KV5Y1
+  NmVHuLtQcNTZy+gRht3ahJRMuC6QyLmkTsf+6MaenwAMkAgHdswGsJztOnNnBa3F
+  y0kCSWmK6D+x/SbfS6r7Ke07MRqziJdB9GuE1+0cIRuFh8EQ+LN6HXCKM5pon/GU
+  ycwMXfl0
+  -----END CERTIFICATE-----
+date: 2013-09-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  version_requirements: !ruby/object:Gem::Requirement
+  name: mini_memory_store
+  requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
+  type: :runtime
   prerelease: false
-  name: mini_memory_store
-  requirement: !ruby/object:Gem::Requirement
+  version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-    none: false
-  type: :runtime
 description: 
 email: michael@grosser.it
 executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .travis.yml
-- Gemfile
-- Gemfile.lock
-- Rakefile
-- Readme.md
-- cachy.gemspec
 - lib/cachy.rb
 - lib/cachy/memcache_timeout_protection.rb
 - lib/cachy/memcached_wrapper.rb
@@ -46,43 +58,28 @@ files:
 - lib/cachy/redis_wrapper.rb
 - lib/cachy/version.rb
 - lib/cachy/wrapper.rb
-- spec/cachy/memcache_timeout_protection_spec.rb
-- spec/cachy/memcached_wrapper_spec.rb
-- spec/cachy/moneta_wrapper_spec.rb
-- spec/cachy/redis_wrapper_spec.rb
-- spec/cachy_spec.rb
-- spec/mem_cache.rb
-- spec/spec_helper.rb
-- spec/test_cache.rb
-homepage: http://github.com/grosser/cachy
+homepage: https://github.com/grosser/cachy
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 966047757035435948
-  none: false
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: '0'
-      segments:
-      - 0
-      hash: 966047757035435948
-  none: false
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.6
 signing_key: 
-specification_version: 3
-summary: Caching library for projects that have many processes or many caches
+specification_version: 4
+summary: See which gems depend on your gems
 test_files: []

data/.travis.yml

@@ -1,5 +0,0 @@
-script: "bundle exec rake"
-rvm:
-  - ree
-  - 1.9.2
-  - 1.9.3

data/Gemfile

@@ -1,6 +0,0 @@
-source :rubygems
-gemspec
-
-gem 'bump'
-gem 'rake'
-gem 'rspec', '~>2'

data/Gemfile.lock

@@ -1,30 +0,0 @@
-PATH
-  remote: .
-  specs:
-    cachy (0.3.1)
-      mini_memory_store
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    bump (0.3.8)
-    diff-lcs (1.1.3)
-    mini_memory_store (0.1.0)
-    rake (10.0.3)
-    rspec (2.12.0)
-      rspec-core (~> 2.12.0)
-      rspec-expectations (~> 2.12.0)
-      rspec-mocks (~> 2.12.0)
-    rspec-core (2.12.2)
-    rspec-expectations (2.12.1)
-      diff-lcs (~> 1.1.3)
-    rspec-mocks (2.12.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  bump
-  cachy!
-  rake
-  rspec (~> 2)

data/Rakefile

@@ -1,7 +0,0 @@
-require 'bundler/setup'
-require 'bundler/gem_tasks'
-require 'bump/tasks'
-
-task :default do
-  sh "rspec spec/"
-end

data/Readme.md

@@ -1,124 +0,0 @@
-Caching library to simplify and organize caching.
-
- - I18n (seperate caches by locale / expires all locales)
- - Generation based (your able expire all caches of one type)
- - Simultanouse caching (handle multiple processes trying to write same expensive 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, but not e.g. sessions)
- - ...
- - works out of the box with Rails
- - works with pure Memcache, Redis 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: 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 code inside the cache 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.<br/>
---> 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.<br/>
-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.cache_if
-Only caches if condition is fulfilled
-    Cachy.cache_if(condition, :foo, 'bar', :expires_in => 1.minute){do_something}
-
-###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 ?<br/>
-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]
-
-### Memcache timeout protection
-If Memcache timeouts keep killing your pages -> [catch MemCache timeouts](http://github.com/grosser/cachy/blob/master/lib/cachy/memcache_timeout_protection)
-
-TODO
-====
- - optionally store dependent keys (:keys=>xxx), so that they can be setup up once and do not need to be remembered
-
-Authors
-=======
-
-###Contributors
- - [mindreframer](http://www.simplewebapp.de/roman)
-
-[Michael Grosser](http://grosser.it)<br/>
-michael@grosser.it<br/>
-License: MIT<br/>
-[![Build Status](https://secure.travis-ci.org/grosser/cachy.png)](http://travis-ci.org/grosser/cachy)
-

data/cachy.gemspec

@@ -1,13 +0,0 @@
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-name = "cachy"
-require "#{name}/version"
-
-Gem::Specification.new name, Cachy::VERSION do |s|
-  s.summary = "Caching library for projects that have many processes or many caches"
-  s.authors = ["Michael Grosser"]
-  s.email = "michael@grosser.it"
-  s.homepage = "http://github.com/grosser/#{name}"
-  s.files = `git ls-files`.split("\n")
-  s.license = "MIT"
-  s.add_runtime_dependency "mini_memory_store"
-end

data/spec/cachy/memcache_timeout_protection_spec.rb

@@ -1,50 +0,0 @@
-require 'spec_helper'
-require './spec/mem_cache'
-require 'cachy/memcache_timeout_protection'
-
-describe "MemCache timeout protection" do
-  before do
-    MemCache.read_error_callback = nil
-  end
-
-  let(:cache){ MemCache.new }
-
-  def simulate_timeout
-    cache.stub!(:stubable_cache_get).and_raise('IO timeout')
-  end
-
-  it "has no errors by default" do
-    cache.read_error_occurred.should == nil
-  end
-
-  it "catches timeout errors" do
-    MemCache.read_error_callback = lambda{|x|}
-    simulate_timeout
-    cache.get('x').should == nil
-    cache.read_error_occurred.should == true
-  end
-
-  it "resets error_occurred to false after successful get" do
-    MemCache.read_error_callback = lambda{|x|}
-    simulate_timeout
-    cache.get('x').should == nil
-    cache.stub!(:stubable_cache_get).and_return 1
-    cache.get('x').should == 1
-    cache.read_error_occurred.should == false
-  end
-
-  it "raises if no callback is given" do
-    simulate_timeout
-    lambda{
-      cache.get('x').should == nil
-    }.should raise_error
-    cache.read_error_occurred.should == true
-  end
-
-  it "calls the callback" do
-    MemCache.read_error_callback = lambda{|x| 1 }
-    simulate_timeout
-    cache.get('x').should == 1
-    cache.read_error_occurred.should == true
-  end
-end

data/spec/cachy/memcached_wrapper_spec.rb

@@ -1,37 +0,0 @@
-require 'spec_helper'
-require './spec/mem_cache'
-
-describe "Cachy::MemcachedWrapper" do
-  before :all do
-    @cache = MemCache.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

@@ -1,59 +0,0 @@
-require '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/redis_wrapper_spec.rb

@@ -1,69 +0,0 @@
-require 'spec_helper'
-
-class TestRedis
-  def self.to_s
-    'Redis'
-  end
-
-  def initialize
-    @wrapped = {}
-  end
-
-  def set(key, object)
-    @wrapped[key] = object
-  end
-
-  def expire(key, seconds)
-  end
-
-  def [](x)
-    @wrapped[x]
-  end
-
-  def clear
-    @wrapped.clear
-  end
-
-  def del(key)
-    @wrapped.delete(key)
-  end
-end
-
-describe "Cachy::RedisWrapper" do
-  let(:yaml_ending) { RUBY_VERSION > '1.9' ? "\n...\n" : "\n" }
-
-  before :all do
-    @cache = TestRedis.new
-    Cachy.cache_store = @cache
-  end
-
-  before do
-    @cache.clear
-  end
-
-  it "is wrapped" do
-    Cachy.cache_store.class.should == Cachy::RedisWrapper
-  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#{yaml_ending}")
-    @cache.should_not_receive(:expire)
-    Cachy.cache(:x){ 'SUCCESS' }.should == 'SUCCESS'
-  end
-
-  it "can cache with expires" do
-    @cache.should_receive(:set).with('x_v1', "--- SUCCESS#{yaml_ending}")
-    @cache.should_receive(:expire).with('x_v1', 1)
-    Cachy.cache(:x, :expires_in=>1){ 'SUCCESS' }.should == 'SUCCESS'
-  end
-
-  it "can expire" do
-    @cache.should_receive(:del).with('x_v1')
-    Cachy.expire(:x)
-  end
-end

data/spec/cachy_spec.rb

@@ -1,405 +0,0 @@
-require 'spec_helper'
-
-describe Cachy do
-
-  def reset_cachy!
-    Cachy.prefix    = nil
-    Cachy.hash_keys = false
-  end
-
-  before do
-    @cache = TestCache.new
-    Cachy.cache_store = @cache
-    @cache.write(Cachy::HEALTH_CHECK_KEY, 'yes')
-    Cachy.send(:class_variable_set, '@@cache_error', false)
-    Cachy.send(:memory_store).clear
-  end
-
-  after do
-    reset_cachy!
-  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 :cache_if do
-    it "should not call the cache command if condition is wrong" do
-      Cachy.should_not_receive(:cache)
-      Cachy.cache_if(false, :x) do
-        "asd"
-      end
-    end
-
-    it "should call cache command if condition is true" do
-      Cachy.should_receive(:cache)
-      Cachy.cache_if(true, :x) do
-        "asd"
-      end
-    end
-
-    it "should pass params correctly" do
-      Cachy.should_receive(:cache).with(:x, {:y => 1}, :expires_in => 3)
-      Cachy.cache_if(true, :x, {:y => 1}, :expires_in => 3) do
-        "asd"
-      end
-    end
-  end
-
-  describe :get do
-    it "gets back an object" do
-      Cachy.cache(:foo){'xxx'}
-      Cachy.get(:foo).should == 'xxx'
-    end
-
-    it "gets complex key" do
-      Cachy.cache(:foo, 1){'xxx'}
-      Cachy.get(:foo).should == nil
-      Cachy.get(:foo, 1).should == 'xxx'
-    end
-
-    it "gets back nil" do
-      Cachy.get(:bar).should == nil
-    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
-
-      @cache.keys.select{|k| k=~ /my_key/}.size.should == 4
-      Cachy.stub!(:locales).and_return locales
-      Cachy.expire(:my_key)
-      @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
-      @cache.keys.should include("another_key_v1")
-      @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" }
-
-      @cache.keys.select{|k| k=~ /my_key/}.size.should == 1
-      Cachy.expire(:my_key)
-      @cache.keys.select{|k| k=~ /my_key/}.size.should == 0
-    end
-
-    it "expires the cache with prefix" do
-      key = 'views/my_key_v1'
-      @cache.write(key, 'x')
-      @cache.read(key).should_not == nil
-      Cachy.expire(:my_key, :prefix=>'views/')
-      @cache.read(key).should == nil
-    end
-  end
-
-  describe :expire_view do
-    it "expires the cache with prefix" do
-      key = 'views/my_key_v1'
-      @cache.write(key, 'x')
-      @cache.read(key).should_not == nil
-      Cachy.expire_view(:my_key)
-      @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
-      # a bit weird but just module I18n does not work with 1.9.1
-      i18n = Module.new
-      i18n.class_eval do
-        def self.locale
-          :de
-        end
-      end
-      Object.const_set :I18n, i18n
-
-      key = Cachy.key(:x)
-      Object.send :remove_const, :I18n #cleanup
-      key.should == "x_v1_de"
-    end
-
-    describe :prefix do
-      it "uses prefix, if set with Cachy.prefix = ..." do
-        user = mock(:cache_key=>'XXX',:something_else=>'YYY')
-        Cachy.prefix = "cachy_"
-        Cachy.key(:my_key, 1, user, "abc").should == 'cachy_my_key_1_XXX_abc_v1'
-      end
-
-      it "can be overridden by :prefix => ... option" do
-        user = mock(:cache_key=>'XXX',:something_else=>'YYY')
-        Cachy.prefix = "cachy_"
-        Cachy.key(:my_key, 1, user, "abc", :prefix => "special_prefix_").should_not == 'cachy_my_key_1_XXX_abc_v1'
-        Cachy.key(:my_key, 1, user, "abc", :prefix => "special_prefix_").should == 'special_prefix_my_key_1_XXX_abc_v1'
-      end
-    end
-
-    describe "with :hash_key" do
-      before do
-        @hash = '3b2b8f418849bc73071375529f8515be'
-      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 = nil
-      Cachy.key_versions.should == {}
-    end
-
-    it "merges in old when setting new" do
-      pending '!!!!!'
-    end
-
-    it "adds a key when cache is called the first time" do
-      Cachy.cache(:xxx){1}
-      Cachy.key_versions[:xxx].should == 1
-      @cache.read(Cachy::KEY_VERSIONS_KEY).should_not == nil
-    end
-
-    it "does not add a key when cache is called the first time and cache is not healthy" do
-      @cache.write(Cachy::HEALTH_CHECK_KEY, 'no')
-      Cachy.cache(:xxx){1}
-      @cache.read(Cachy::KEY_VERSIONS_KEY).should == nil
-    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.key_versions.should == {} # fills cache
-      @cache.write Cachy::KEY_VERSIONS_KEY, {:xx=>1}
-      Cachy.send(:memory_store).clear
-      Cachy.key_versions.should == {:xx=>1}
-    end
-
-    it "expires when key_versions is set" do
-      Cachy.key_versions.should == {}
-      Cachy.key_versions = {:xx => 1}
-      Cachy.key_versions.should == {:xx => 1}
-    end
-  end
-
-  describe :key_versions, "with timeout" do
-    before do
-      @mock = mock = {}
-      @cache.instance_eval{@data = mock}
-      def @mock.read_error_occurred
-        false
-      end
-      def @mock.[](x)
-        {:x => 1}
-      end
-      Cachy.send(:class_variable_set, '@@cache_error', false)
-    end
-
-    it "reads normally" do
-      Cachy.send(:read_versions).should == {:x => 1}
-    end
-
-    it "reads empty when it crashes" do
-      @mock.should_receive(:[]).and_return nil # e.g. Timout happended
-      @mock.should_receive(:read_error_occurred).and_return true
-      Cachy.send(:read_versions).should == {}
-    end
-
-    it "marks as error when it crashes" do
-      Cachy.send(:class_variable_get, '@@cache_error').should == false
-      @mock.should_receive(:read_error_occurred).and_return true
-      Cachy.send(:read_versions)
-      Cachy.send(:class_variable_get, '@@cache_error').should == true
-    end
-
-    it "marks as error free when it reads successfully" do
-      Cachy.send(:class_variable_set, '@@cache_error', true)
-      Cachy.send(:class_variable_get, '@@cache_error').should == true
-      Cachy.send(:read_versions).should == {:x => 1}
-      Cachy.send(:class_variable_get, '@@cache_error').should == false
-    end
-
-    it "writes when it was not error before" do
-      Cachy.cache_store.should_receive(:write)
-      Cachy.send(:write_version, {})
-    end
-
-    it "does not write when it was error before" do
-      Cachy.send(:class_variable_set, '@@cache_error', true)
-      Cachy.cache_store.should_not_receive(:write)
-      Cachy.send(:write_version, {})
-    end
-  end
-
-  describe :key_versions, 'with separate store' do
-    let(:key_cache){ TestCache.new }
-
-    it "reads from separate store" do
-      key_cache.write(Cachy::KEY_VERSIONS_KEY, :x => 1)
-      Cachy.key_versions_cache_store = key_cache
-      Cachy.key_versions.should == {:x => 1}
-    end
-
-    it "writes to separate store" do
-      key_cache.write(Cachy::KEY_VERSIONS_KEY, :x => 1)
-      Cachy.key_versions_cache_store = key_cache
-      Cachy.increment_key :x
-      Cachy.key_versions.should == {:x => 2}
-    end
-
-    it "invalidates the cached key_versions_cache_store when a new cache store is used" do
-      key_cache.write(Cachy::KEY_VERSIONS_KEY, :x => 1)
-      Cachy.key_versions_cache_store = key_cache
-      Cachy.key_versions.should == {:x => 1}
-      Cachy.cache_store = @cache
-      Cachy.key_versions.should == {}
-    end
-  end
-
-  describe :delete_key do
-    it "removes a key from key versions" do
-      Cachy.cache(:xxx){1}
-      Cachy.key_versions.key?(:xxx).should == true
-      Cachy.delete_key :xxx
-      Cachy.key_versions.key?(:xxx).should == false
-    end
-
-    it "does not crash with unfound key" do
-      Cachy.delete_key :xxx
-      Cachy.delete_key :xxx
-      Cachy.key_versions.key?(:xxx).should == false
-    end
-  end
-end

data/spec/mem_cache.rb

@@ -1,35 +0,0 @@
-# stub to test memcache integration
-class MemCache
-  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)
-    cache_get(key)
-  end
-
-  def cache_get(key)
-    stubable_cache_get(key)
-  end
-
-  def stubable_cache_get(key)
-    @wrapped[key]
-  end
-
-  def [](x)
-    @wrapped[x]
-  end
-
-  def clear
-    @wrapped.clear
-  end
-
-  def delete(key)
-    @wrapped.delete(key)
-  end
-end

data/spec/spec_helper.rb

@@ -1,3 +0,0 @@
-require './spec/test_cache'
-$LOAD_PATH << 'lib'
-require 'cachy'

data/spec/test_cache.rb

@@ -1,25 +0,0 @@
-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