cachy 0.1.3 → 0.1.4

data/README.markdown

@@ -71,12 +71,15 @@ When they are updated the cache is automatically expired.
 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
@@ -86,20 +89,17 @@ Expires all locales of a key
     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]

data/Rakefile

@@ -1,6 +1,6 @@
 task :default => :spec
 require 'spec/rake/spectask'
-Spec::Rake::SpecTask.new {|t| t.spec_opts = ['--color']}
+Spec::Rake::SpecTask.new {|t| t.spec_opts = ['--color --backtrace']}
 
 begin
   require 'jeweler'

data/VERSION

@@ -1 +1 @@
-0.1.3
+0.1.4

data/cachy.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{cachy}
-  s.version = "0.1.3"
+  s.version = "0.1.4"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Michael Grosser"]
-  s.date = %q{2009-11-22}
+  s.date = %q{2010-08-14}
   s.email = %q{grosser.michael@gmail.com}
   s.extra_rdoc_files = [
     "README.markdown"
@@ -23,7 +23,6 @@ Gem::Specification.new do |s|
      "lib/cachy/memcached_wrapper.rb",
      "lib/cachy/moneta_wrapper.rb",
      "lib/cachy/wrapper.rb",
-     "rdoc/README.rdoc",
      "spec/cachy/memcached_wrapper_spec.rb",
      "spec/cachy/moneta_wrapper_spec.rb",
      "spec/cachy_spec.rb",
@@ -33,14 +32,14 @@ Gem::Specification.new do |s|
   s.homepage = %q{http://github.com/grosser/cachy}
   s.rdoc_options = ["--charset=UTF-8"]
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.3.5}
+  s.rubygems_version = %q{1.3.6}
   s.summary = %q{Caching library for projects that have many processes or many caches}
   s.test_files = [
-    "spec/spec_helper.rb",
-     "spec/test_cache.rb",
-     "spec/cachy/memcached_wrapper_spec.rb",
+    "spec/cachy/memcached_wrapper_spec.rb",
      "spec/cachy/moneta_wrapper_spec.rb",
-     "spec/cachy_spec.rb"
+     "spec/cachy_spec.rb",
+     "spec/test_cache.rb",
+     "spec/spec_helper.rb"
   ]
 
   if s.respond_to? :specification_version then

data/lib/cachy.rb

@@ -1,6 +1,10 @@
 class Cachy
   WHILE_RUNNING_TMEOUT = 5*60 #seconds
   KEY_VERSION_TIMEOUT = 30 #seconds
+  HEALTH_CHECK_KEY = 'cachy_healthy'
+  KEY_VERSIONS_KEY = 'cachy_key_versions'
+
+  @@cache_error = false
 
   # Cache the result of a block
   #
@@ -13,7 +17,6 @@ class Cachy
     key = key(*args)
     options = extract_options!(args)
 
-    # Cached result?
     result = cache_store.read(key)
     return result unless result == nil
 
@@ -24,6 +27,14 @@ class Cachy
     cache_store.write key, result, options
     result
   end
+  
+  def self.cache_if(cond, *args, &block)
+    if cond
+      cache(*args, &block)
+    else
+      block.call
+    end
+  end
 
   # Constructs a cache-key (first argument must be a String/Symbol)
   #
@@ -43,7 +54,7 @@ class Cachy
     end * "_"
 
     key = (options[:hash_key] || hash_keys) ? hash(key) : key
-    options[:prefix].to_s + key + options[:suffix].to_s
+    (options[:prefix].to_s + key + options[:suffix].to_s).gsub(' ', '_')
   end
 
   # Expire all possible locales of a cache, use the same arguments as with cache
@@ -72,7 +83,7 @@ class Cachy
   @@key_versions = {:versions=>{}, :last_set=>0}
   def self.key_versions
     if key_versions_expired?
-      versions = cache_store.read("cachy_key_versions") || {}
+      versions = read_versions
       @@key_versions = {:versions=>versions, :last_set=>Time.now.to_i}
     end
     @@key_versions[:versions]
@@ -80,22 +91,29 @@ class Cachy
 
   def self.key_versions=(data)
     @@key_versions[:last_set] = 0 #expire current key
-    cache_store.write("cachy_key_versions", data)
+    write_version(data)
   end
 
   # Expires all caches that use this key
   def self.increment_key(key)
     key = key.to_sym
-    version = key_versions[key] || 0
+    current_versions = read_versions
+    version = current_versions[key] || 0
     version += 1
-    self.key_versions = key_versions.merge(key => version)
+    self.key_versions = current_versions.merge(key => version)
     version
   end
 
+  def self.delete_key(key)
+    versions = key_versions.dup
+    versions.delete(key.to_sym)
+    self.key_versions = versions
+  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)
@@ -110,6 +128,7 @@ class Cachy
     else
       raise "This cache_store type is not usable for Cachy!"
     end
+    @cache_store.write HEALTH_CHECK_KEY, 'yes'
   end
 
   def self.cache_store
@@ -135,6 +154,25 @@ class Cachy
 
   private
 
+  def self.read_versions
+    data = cache_store.instance_variable_get('@data')
+    if data.respond_to? :read_error_occured # its a MemCache with read_error detection !
+      result = data[KEY_VERSIONS_KEY] || {}
+      @@cache_error = data.read_error_occured
+      result
+    else
+      cache_store.read(KEY_VERSIONS_KEY) || {}
+    end
+  end
+
+  def self.write_version(data)
+    cache_store.write(KEY_VERSIONS_KEY, data) unless @@cache_error
+  end
+
+  def self.cache_healthy?
+    cache_store.read(HEALTH_CHECK_KEY) == 'yes'
+  end
+
   # 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
@@ -167,7 +205,7 @@ class Cachy
 
   def self.key_version_for(key)
     key = key.to_sym
-    key_versions[key] || increment_key(key)
+    key_versions[key] || (cache_healthy? ? increment_key(key) : 1)
   end
 
   def self.ensure_valid_keys(options)

data/spec/cachy_spec.rb

@@ -1,27 +1,25 @@
 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
+    @cache = TestCache.new
+    Cachy.cache_store = @cache
+    Cachy.class_eval "@@key_versions = {:versions=>{}, :last_set=>0}"
+    @cache.write(Cachy::HEALTH_CHECK_KEY, 'yes')
+    Cachy.send(:class_variable_set, '@@cache_error', false)
   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'
@@ -51,6 +49,29 @@ describe Cachy do
       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 :expire do
     it "expires the cache for all languages" do
@@ -62,10 +83,10 @@ describe Cachy do
         Cachy.cache(:my_key){ l }
       end
 
-      TEST_CACHE.keys.select{|k| k=~ /my_key/}.size.should == 4
+      @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
+      @cache.keys.select{|k| k=~ /my_key/}.size.should == 0
     end
 
     it "does not expire other keys" do
@@ -73,35 +94,35 @@ describe Cachy do
       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")
+      @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" }
 
-      TEST_CACHE.keys.select{|k| k=~ /my_key/}.size.should == 1
+      @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
+      @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
+      @cache.write(key, 'x')
+      @cache.read(key).should_not == nil
       Cachy.expire(:my_key, :prefix=>'views/')
-      TEST_CACHE.read(key).should == nil
+      @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
+      @cache.write(key, 'x')
+      @cache.read(key).should_not == nil
       Cachy.expire_view(:my_key)
-      TEST_CACHE.read(key).should == nil
+      @cache.read(key).should == nil
     end
   end
 
@@ -121,11 +142,15 @@ describe Cachy do
     end
 
     it "gets the locale from I18n" do
-      module I18n
+      # 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"
@@ -205,13 +230,24 @@ describe Cachy do
 
   describe :key_versions do
     before do
-      Cachy.key_versions = {}
+      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
@@ -228,13 +264,13 @@ describe Cachy do
 
     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}
+      @cache.write Cachy::KEY_VERSIONS_KEY, {: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}
+      @cache.write Cachy::KEY_VERSIONS_KEY, {:xx=>1}
       Cachy.key_versions.should == {:xx=>2}
     end
 
@@ -244,4 +280,68 @@ describe Cachy do
       Cachy.key_versions[:xx].should == 1
     end
   end
+
+  describe :key_versions, "with timeout" do
+    before do
+      @mock = mock = {}
+      @cache.instance_eval{@data = mock}
+      def @mock.read_error_occured
+        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_occured).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_occured).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 :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

metadata

@@ -1,7 +1,12 @@
 --- !ruby/object:Gem::Specification 
 name: cachy
 version: !ruby/object:Gem::Version 
-  version: 0.1.3
+  prerelease: false
+  segments: 
+  - 0
+  - 1
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - Michael Grosser
@@ -9,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-22 00:00:00 +01:00
+date: 2010-08-14 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -30,7 +35,6 @@ files:
 - lib/cachy/memcached_wrapper.rb
 - lib/cachy/moneta_wrapper.rb
 - lib/cachy/wrapper.rb
-- rdoc/README.rdoc
 - spec/cachy/memcached_wrapper_spec.rb
 - spec/cachy/moneta_wrapper_spec.rb
 - spec/cachy_spec.rb
@@ -49,24 +53,26 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 required_rubygems_version: !ruby/object:Gem::Requirement 
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
+      segments: 
+      - 0
       version: "0"
-  version: 
 requirements: []
 
 rubyforge_project: 
-rubygems_version: 1.3.5
+rubygems_version: 1.3.6
 signing_key: 
 specification_version: 3
 summary: Caching library for projects that have many processes or many caches
 test_files: 
-- spec/spec_helper.rb
-- spec/test_cache.rb
 - spec/cachy/memcached_wrapper_spec.rb
 - spec/cachy/moneta_wrapper_spec.rb
 - spec/cachy_spec.rb
+- spec/test_cache.rb
+- spec/spec_helper.rb

data/rdoc/README.rdoc

@@ -1 +0,0 @@
-documentation is at http://github.com/grosser/cachy