cachetastic 3.1.0 → 3.2.0

data/Gemfile

@@ -4,4 +4,5 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'memcache-client'
-gem 'rspec'
+gem 'rspec'
+gem 'timecop'

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    cachetastic (3.1.0)
+    cachetastic (3.2.0)
       activesupport
       configatron
 
@@ -26,6 +26,7 @@ GEM
     rspec-expectations (2.12.1)
       diff-lcs (~> 1.1.3)
     rspec-mocks (2.12.1)
+    timecop (0.5.7)
     yamler (0.1.0)
 
 PLATFORMS
@@ -36,3 +37,4 @@ DEPENDENCIES
   memcache-client
   rake
   rspec
+  timecop

data/README.md

@@ -1,4 +1,4 @@
-h1. What is Cachetastic?
+# What is Cachetastic?
 
 Cachetastic is an incredibly easy to use and administer caching framework. Just because it is easy to use, does not mean that it is light with features. Cachetastic allows you to create classes that extend <code>Cachetastic::Cache</code>, configure them each individually, and much more.
 
@@ -6,88 +6,88 @@ Unlike other systems each cache in your system can use different backends via th
 
 Adapters are easy to write, so if the built in adapters don't float your boat, you can easily knock one off in short order.
 
-h2. Configuration:
+## Configuration:
 
-Configuration of Cachetastic is done using the Configatron gem. I would recommend reading the documentation on it first, hcodep://configatron.mackframework.com, before continuing.
+Configuration of Cachetastic is done using the Configatron gem.
 
 All configuration settings hang off of the <code>cachetastic</code> namespace on <code>configatron</code>. The default settings all hang off the <code>defaults</code> namespace on the <code>cachetastic</code> namespace, as shown below:
 
-<pre><code>
-  # This will write detailed information to the logger.
-  configatron.cachetastic.defaults.debug = false
-
-  # This is the type of file store to be used for this cache.
-  # More adapters can be developed and plugged in as desired.
-  # The default is Cachetastic::Adapters::LocalMemory
-  configatron.cachetastic.defaults.adapter = Cachetastic::Adapters::LocalMemory
-  configatron.cachetastic.defaults.adapter = Cachetastic::Adapters::File
-  configatron.cachetastic.defaults.adapter = Cachetastic::Adapters::Memcached
-
-  # This will marshall objects into and out of the store.
-  # The default is :none, except for Cachetastic::Adapters::File, which defaults to :yaml
-  configatron.cachetastic.defaults.marshall_method = :none
-  configatron.cachetastic.defaults.marshall_method = :yaml
-  configatron.cachetastic.defaults.marshall_method = :ruby
-
-  # This sets how long objects will live in the cache before they are auto expired.
-  configatron.cachetastic.defaults.default_expiry = 86400 # time in seconds (default: 24 hours)
-
-  # When secodeing objects into the cache the expiry_swing is +/- to the expiry time.
-  # Example: if the expiry time is 1 minute, and the swing is 15 seconds,
-  # objects will go into the cache with an expiry time sometime between 45 seconds and 75 seconds.
-  # The default is 0 seconds.
-  configatron.cachetastic.defaults.expiry_swing = 15
-
-  # Configure logging for the system.
-  # n number of logs can be configured for a cache.
-  log_1 = Logger.new(STDOUT)
-  log_1.level = Logger::DEBUG
-  log_2 = Logger.new("log/cachetastic.log")
-  log_2.level = Logger::ERROR
-  configatron.cachetastic.defaults.logger = [log_1, log_2]
-</code></pre>
+```ruby
+# This will write detailed information to the logger.
+configatron.cachetastic.defaults.debug = false
+
+# This is the type of file store to be used for this cache.
+# More adapters can be developed and plugged in as desired.
+# The default is Cachetastic::Adapters::LocalMemory
+configatron.cachetastic.defaults.adapter = Cachetastic::Adapters::LocalMemory
+configatron.cachetastic.defaults.adapter = Cachetastic::Adapters::File
+configatron.cachetastic.defaults.adapter = Cachetastic::Adapters::Memcached
+
+# This will marshall objects into and out of the store.
+# The default is :none, except for Cachetastic::Adapters::File, which defaults to :yaml
+configatron.cachetastic.defaults.marshall_method = :none
+configatron.cachetastic.defaults.marshall_method = :yaml
+configatron.cachetastic.defaults.marshall_method = :ruby
+
+# This sets how long objects will live in the cache before they are auto expired.
+configatron.cachetastic.defaults.default_expiry = 86400 # time in seconds (default: 24 hours)
+
+# When secodeing objects into the cache the expiry_swing is +/- to the expiry time.
+# Example: if the expiry time is 1 minute, and the swing is 15 seconds,
+# objects will go into the cache with an expiry time sometime between 45 seconds and 75 seconds.
+# The default is 0 seconds.
+configatron.cachetastic.defaults.expiry_swing = 15
+
+# Configure logging for the system.
+# n number of logs can be configured for a cache.
+log_1 = Logger.new(STDOUT)
+log_1.level = Logger::DEBUG
+log_2 = Logger.new("log/cachetastic.log")
+log_2.level = Logger::ERROR
+configatron.cachetastic.defaults.logger = [log_1, log_2]
+```
 
 Overriding settings per cache is very simple. Let's take the following two caches:
 
-<pre><code>
-  class UserCache < Cachetastic::Cache
-  end
+```ruby
+class UserCache < Cachetastic::Cache
+end
 
-  class Admin::UserCache < Cachetastic::Cache
-  end
-</code></pre>
+class Admin::UserCache < Cachetastic::Cache
+end
+```
 
 If we wanted to set the <code>UserCache</code> to use the <code>Cachetastic::Adapters::File</code> adapter and we wanted to set the adapter for 
 the <code>Admin::UserCache</code> to use <code>Cachetastic::Adapters::Memcached</code>, we would configure them like such:
 
-<pre><code>
-  configatron.cachetastic.user_cache.adapter = Cachetastic::Adapters::File
-  configatron.cachetastic.admin.user_cache.adapter = Cachetastic::Adapters::Memcached
-</code></pre>
+```ruby
+configatron.cachetastic.user_cache.adapter = Cachetastic::Adapters::File
+configatron.cachetastic.admin.user_cache.adapter = Cachetastic::Adapters::Memcached
+```
 
 In this scenario we have changed the adapters for each of the classes. All of the other default settings will remain intact for each of those classes. This makes it incredibly easy to just change the one parameter you need, and not have to reset them all.
     
-h2. Examples:
-
-<pre><code>
-  class MyAwesomeCache < Cachetastic::Cache
-  end
-  
-  MyAwesomeCache.set(1, [1,2,3])
-  MyAwesomeCache.get(1) # => [1,2,3] 
-  
-  class MyAwesomeCache < Cachetastic::Cache
-    class << self
-      def get(key, x, y)
-        super(key) do
-          n = x + y
-          set(key, n)
-          n
-        end
+## Examples:
+
+```ruby
+class MyAwesomeCache < Cachetastic::Cache
+end
+
+MyAwesomeCache.set(1, [1,2,3])
+MyAwesomeCache.get(1) # => [1,2,3]
+
+class MyAwesomeCache < Cachetastic::Cache
+  class << self
+    def get(key, x, y)
+      super(key) do
+        n = x + y
+        set(key, n)
+        n
       end
     end
   end
-  
-  MyAwesomeCache.get(1, 2, 4) # => 8
-  MyAwesomeCache.get(1, 4, 4) # => 8
-</code></pre>
+end
+
+MyAwesomeCache.get(1, 2, 4) # => 8
+MyAwesomeCache.get(1, 4, 4) # => 8
+```

data/lib/cachetastic/adapters/file.rb

@@ -38,7 +38,10 @@ module Cachetastic # :nodoc:
       end # set
       
       def delete(key) # :nodoc:
-        FileUtils.rm(file_path(key))
+        path = file_path(key)
+        if ::File.exists?(path)
+          FileUtils.rm(path)
+        end
       end # delete
       
       def expire_all # :nodoc:

data/lib/cachetastic/adapters/memcached.rb

@@ -6,11 +6,11 @@ module Cachetastic # :nodoc:
     # in addition to the default settings:
     # 
     #   configatron.cachetastic.defaults.servers = ['127.0.0.1:11211']
-    #   configatron.cachetastic.defaults.mc_options = {:c_threshold => 10_000,
-    #                                                  :compression => true,
-    #                                                  :debug => false,
-    #                                                  :readonly => false,
-    #                                                  :urlencode => false}
+    #   configatron.cachetastic.defaults.mc_options = {c_threshold: 10_000,
+    #                                                  compression: true,
+    #                                                  debug: false,
+    #                                                  readonly: false,
+    #                                                  urlencode: false}
     #   configatron.cachetastic.delete_delay = 0
     # 
     # The <tt>servers</tt> setting defines an <tt>Array</tt> of Mecached
@@ -34,11 +34,11 @@ module Cachetastic # :nodoc:
         define_accessor(:delete_delay)
         self.delete_delay = 0
         self.servers = ['127.0.0.1:11211']
-        self.mc_options = {:c_threshold => 10_000,
-                           :compression => true,
-                           :debug => false,
-                           :readonly => false,
-                           :urlencode => false}
+        self.mc_options = {c_threshold: 10_000,
+                           compression: true,
+                           debug: false,
+                           readonly: false,
+                           urlencode: false}
         super
         connection
       end
@@ -76,14 +76,14 @@ module Cachetastic # :nodoc:
       private
       def connection
         unless @_mc_connection && valid? && @_ns_version == get_version
-          @_mc_connection = MemCache.new(self.servers, self.mc_options.merge(:namespace => namespace))
+          @_mc_connection = MemCache.new(self.servers, self.mc_options.merge(namespace: namespace))
         end
         @_mc_connection
       end
       
       def ns_connection
         if !@_ns_connection || !@_ns_connection.active?
-          @_ns_connection = MemCache.new(self.servers, self.mc_options.merge(:namespace => :namespace_versions))
+          @_ns_connection = MemCache.new(self.servers, self.mc_options.merge(namespace: :namespace_versions))
         end
         @_ns_connection
       end

data/lib/cachetastic/cache.rb

@@ -13,11 +13,9 @@ module Cachetastic # :nodoc:
   #   MyAwesomeCache.get(1) # => nil
   # 
   #   class MyAwesomeCache < Cachetastic::Cache
-  #     class << self
-  #       def get(key)
-  #         super(key) do
-  #           set(key, key * 10)
-  #         end
+  #     def get(key)
+  #       super(key) do
+  #         set(key, key * 10)
   #       end
   #     end
   #   end
@@ -27,170 +25,179 @@ module Cachetastic # :nodoc:
   #   MyAwesomeCache.delete(1)
   #   MyAwesomeCache.get(1) # => 10
   class Cache
+    include Singleton
     
     # everything is done at the class level. there won't be any 'instances of it'
     # using class << self means we don't have to prefix each method with 'self.'
     class << self
-      
-      # Returns an object from the cache for a given key.
-      # If the object comes back as nil and a block is given
-      # that block will be run and the results of the block
-      # will be returned. This can be used to JIT caches, just make
-      # sure in the block to call the set method because the
-      # results of the block are not automatically cached.
-      def get(key, &block)
-        do_with_logging(:get, key) do
-          retryable do
-            val = self.adapter.get(key)
-            handle_store_object(key, adapter.unmarshal(val), &block)
-          end
-        end
-      end # get
-      
-      # Set a particular object info the cache for the given key.
-      # 
-      # An optional third parameter sets the expiry time for the object in the cache.
-      # If no expiry_time is passed in then the default expiry_time that has been configured
-      # will be used.
-      # 
-      # If there is an the expiry_swing setting is configured it will be +/- to the
-      # expiry time.
-      def set(key, value, expiry_time = nil)
-        do_with_logging(:set, key) do
-          retryable do
-            self.adapter.set(key, value, calculate_expiry_time(expiry_time))
-          end
+
+      def method_missing(sym, *args, &block)
+        self.instance.send(sym, *args, &block)
+      end
+
+    end # class << self
+
+    # Returns an object from the cache for a given key.
+    # If the object comes back as nil and a block is given
+    # that block will be run and the results of the block
+    # will be returned. This can be used to JIT caches, just make
+    # sure in the block to call the set method because the
+    # results of the block are not automatically cached.
+    def get(key, &block)
+      do_with_logging(:get, key) do
+        retryable do
+          val = self.adapter.get(key)
+          handle_store_object(key, adapter.unmarshal(val), &block)
         end
-      end # set
-      
-      # Deletes an object from the cache.
-      def delete(key)
-        do_with_logging(:delete, key) do
-          retryable do
-            self.adapter.delete(key)
-            nil
-          end
+      end
+    end # get
+
+    # Set a particular object info the cache for the given key.
+    #
+    # An optional third parameter sets the expiry time for the object in the cache.
+    # If no expiry_time is passed in then the default expiry_time that has been configured
+    # will be used.
+    #
+    # If there is an the expiry_swing setting is configured it will be +/- to the
+    # expiry time.
+    def set(key, value, expiry_time = nil)
+      do_with_logging(:set, key) do
+        retryable do
+          self.adapter.set(key, value, calculate_expiry_time(expiry_time))
         end
-      end # delete
-      
-      # Expires all objects for this cache.
-      def expire_all
-        do_with_logging(:expire_all, nil) do
-          retryable do
-            self.adapter.expire_all
-            nil
-          end
+      end
+    end # set
+
+    # Deletes an object from the cache.
+    def delete(key)
+      do_with_logging(:delete, key) do
+        retryable do
+          self.adapter.delete(key)
+          nil
         end
-      end # expire_all
-      
-      # Returns the underlying Cachetastic::Adapters::Base for this cache.
-      def adapter
-        unless @_adapter && @_adapter.valid?
-          @_adapter = Cachetastic::Adapters.build(cache_klass)
+      end
+    end # delete
+
+    # Expires all objects for this cache.
+    def expire_all
+      do_with_logging(:expire_all, nil) do
+        retryable do
+          self.adapter.expire_all
+          nil
         end
-        @_adapter
-      end # adapter
-      
-      # Clears the adapter so it can be redefined. This is useful if you have
-      # reconfigured the cache to use a different adapater, or different settings.
-      def clear_adapter!
-        @_adapter = nil
       end
-      
-      def cache_klass # :nodoc:
-        self
+    end # expire_all
+
+    # Returns the underlying Cachetastic::Adapters::Base for this cache.
+    def adapter
+      unless @_adapter && @_adapter.valid?
+        @_adapter = Cachetastic::Adapters.build(cache_klass)
       end
-      
-      # Returns the Cachetastic::Logger for this cache.
-      def logger
-        unless @_logger
-          @_logger = Cachetastic::Logger.new(adapter.logger)
-        end
-        @_logger
+      @_adapter
+    end # adapter
+
+    # Clears the adapter so it can be redefined. This is useful if you have
+    # reconfigured the cache to use a different adapater, or different settings.
+    def clear_adapter!
+      @_adapter = nil
+    end
+
+    def cache_klass # :nodoc:
+      self.class
+    end
+
+    # Returns the Cachetastic::Logger for this cache.
+    def logger
+      unless @_logger
+        @_logger = Cachetastic::Logger.new(adapter.logger)
       end
-      
-      private
-      # If the expiry time is set to 60 minutes and the expiry_swing time is set to
-      # 15 minutes, this method will return a number between 45 minutes and 75 minutes.
-      def calculate_expiry_time(expiry_time) # :doc:
-        expiry_time = self.adapter.default_expiry if expiry_time.nil?
-        exp_swing = self.adapter.expiry_swing
-        if exp_swing && exp_swing != 0
-          swing = rand(exp_swing.to_i)
-          case rand(2)
-          when 0
-            expiry_time = (expiry_time.to_i + swing)
-          when 1
-            expiry_time = (expiry_time.to_i - swing)
-          end
+      @_logger
+    end
+
+    def to_configatron(*args) # :nodoc:
+      self.class.to_configatron(*args)
+    end
+
+    private
+    # If the expiry time is set to 60 minutes and the expiry_swing time is set to
+    # 15 minutes, this method will return a number between 45 minutes and 75 minutes.
+    def calculate_expiry_time(expiry_time) # :doc:
+      expiry_time = self.adapter.default_expiry if expiry_time.nil?
+      exp_swing = self.adapter.expiry_swing
+      if exp_swing && exp_swing != 0
+        swing = rand(exp_swing.to_i)
+        case rand(2)
+        when 0
+          expiry_time = (expiry_time.to_i + swing)
+        when 1
+          expiry_time = (expiry_time.to_i - swing)
         end
-        expiry_time
       end
-      
-      def handle_store_object(key, val, &block)
-        if val.is_a?(Cachetastic::Cache::StoreObject)
-          if val.expired?
-            self.delete(key)
-            val = nil
-          else
-            val = val.value
-          end
-        end
-        
-        if val.respond_to?(:empty?)
-          val = nil if val.empty?
-        elsif val.respond_to?(:blank?)
-          val = nil if val.blank?
+      expiry_time
+    end
+
+    def handle_store_object(key, val, &block)
+      if val.is_a?(Cachetastic::Cache::StoreObject)
+        if val.expired?
+          self.delete(key)
+          val = nil
+        else
+          val = val.value
         end
-        return val unless val.nil?
-        
-        val = yield key if block_given?
-        return val
       end
+
+      if val.respond_to?(:empty?)
+        val = nil if val.empty?
+      elsif val.respond_to?(:blank?)
+        val = nil if val.blank?
+      end
+      return val unless val.nil?
       
-      def do_with_logging(action, key)
-        if adapter.debug?
-          start_time = Time.now
-          logger.debug(:starting, action, cache_klass.name, key)
-          res = yield if block_given?
-          end_time = Time.now
-          str = ''
-          unless res.nil?
-            str = "[#{res.class.name}]"
-            str << "\t[Size = #{res.size}]" if res.respond_to? :size
-            str << "\t" << res.inspect
-          end
-          logger.debug(:finished, action, cache_klass.name, key, (end_time - start_time), str)
-          return res
-        else
-          return yield(key) if block_given?
+      val = yield key if block_given?
+      return val
+    end
+
+    def do_with_logging(action, key)
+      if adapter.debug?
+        start_time = Time.now
+        logger.debug(:starting, action, cache_klass.name, key)
+        res = yield if block_given?
+        end_time = Time.now
+        str = ''
+        unless res.nil?
+          str = "[#{res.class.name}]"
+          str << "\t[Size = #{res.size}]" if res.respond_to? :size
+          str << "\t" << res.inspect
         end
+        logger.debug(:finished, action, cache_klass.name, key, (end_time - start_time), str)
+        return res
+      else
+        return yield(key) if block_given?
       end
-      
-      def retryable(options = {}, &block)
-        opts = { :tries => 3, :on => Exception }.merge(options)
-
-        retries = opts[:tries]
-        retry_exceptions = [opts[:on]].flatten
-
-        x = %{
-          begin
-            return yield
-          rescue #{retry_exceptions.join(", ")} => e
-            retries -= 1
-            if retries > 0
-              clear_adapter!
-              retry
-            else
-              raise e
-            end
+    end
+
+    def retryable(options = {}, &block)
+      opts = { tries: 3, on: Exception }.merge(options)
+
+      retries = opts[:tries]
+      retry_exceptions = [opts[:on]].flatten
+
+      x = %{
+        begin
+          return yield
+        rescue #{retry_exceptions.join(", ")} => e
+          retries -= 1
+          if retries > 0
+            clear_adapter!
+            retry
+          else
+            raise e
           end
-        }
+        end
+      }
 
-        eval(x, &block)
-      end
-      
-    end # class << self
+      eval(x, &block)
+    end
     
   end # Cache
 end # Cachetastic

data/lib/cachetastic/cacheable.rb

@@ -48,7 +48,7 @@ module Cachetastic # :nodoc:
           eval %{
             class #{c_name} < Cachetastic::Cache
               
-              def self.cache_klass
+              def cache_klass
                 #{n}
               end
               

data/lib/cachetastic/version.rb

@@ -1,3 +1,3 @@
 module Cachetastic
-  VERSION = "3.1.0"
+  VERSION = "3.2.0"
 end

data/lib/cachetastic.rb

@@ -2,6 +2,7 @@ require 'configatron'
 require 'logger'
 require 'active_support/core_ext'
 require 'fileutils'
+require 'singleton'
 begin
   require 'memcache'
 rescue Exception => e

data/spec/cachetastic/adapters/base_spec.rb

@@ -99,6 +99,7 @@ describe Cachetastic::Adapters do
       before(:each) do
         configatron.cachetastic.defaults.adapter = "Cachetastic::Adapters::#{adapter}".constantize
         CarCache.clear_adapter!
+        CarCache.expire_all
         CarCache.set(:vw, 'Rabbit')
       end
 
@@ -153,12 +154,14 @@ describe Cachetastic::Adapters do
           CarCache.get(:bmw).should_not be_nil
         end
         
-        it 'should set an object into the cache with an expiry' do
-          CarCache.get(:bmw).should be_nil
-          CarCache.set(:bmw, 'Beamer!', 1)
-          CarCache.get(:bmw).should_not be_nil
-          sleep(2)
-          CarCache.get(:bmw).should be_nil
+        unless adapter == "Memcached"
+          it 'should set an object into the cache with an expiry' do
+            CarCache.get(:bmw).should be_nil
+            CarCache.set(:bmw, 'Beamer!', 1)
+            CarCache.get(:bmw).should_not be_nil
+            Timecop.travel(1.hour.from_now)
+            CarCache.get(:bmw).should be_nil
+          end
         end
 
       end
@@ -188,7 +191,7 @@ describe Cachetastic::Adapters do
       describe 'retry' do
         
         it 'should retry if there is an exception' do
-          CarCache.should_receive(:clear_adapter!).twice
+          CarCache.instance.should_receive(:clear_adapter!).twice
           lambda {
             CarCache.get(:audi) do
               raise Cachetastic::BlockError.new

data/spec/cachetastic/cache_spec.rb

@@ -65,11 +65,6 @@ describe Cachetastic::Cache do
       configatron.temp do
         configatron.cachetastic.defaults.expiry_swing = 15
         configatron.cachetastic.defaults.default_expiry = 60
-        SimpleCache.class_eval do
-          class << self
-            public :calculate_expiry_time
-          end
-        end
         10.times do
           SimpleCache.calculate_expiry_time(60).should >= 45
           SimpleCache.calculate_expiry_time(60).should <= 75

data/spec/cachetastic/cacheable_spec.rb

@@ -28,14 +28,14 @@ describe Cachetastic::Cacheable do
     
     it 'should create a new cache class if one doesnt already exist' do
       MyObject.cache_class.should == Cachetastic::Cacheable::MyObjectCache
-      Cachetastic::Cacheable::MyObjectCache.new.should be_kind_of(Cachetastic::Cache)
+      Cachetastic::Cacheable::MyObjectCache.instance.should be_kind_of(Cachetastic::Cache)
     end
     
     it 'should handle namespaced classes correctly' do
       Cachetastic::Cacheable.should_not be_const_defined(:My_Namespaced_ThingCache)
       My::Namespaced::Thing.cache_class.should == Cachetastic::Cacheable::My_Namespaced_ThingCache
       Cachetastic::Cacheable.should be_const_defined(:My_Namespaced_ThingCache)
-      Cachetastic::Cacheable::My_Namespaced_ThingCache.new.should be_kind_of(Cachetastic::Cache)
+      Cachetastic::Cacheable::My_Namespaced_ThingCache.instance.should be_kind_of(Cachetastic::Cache)
     end
     
     it 'should override cache_klass to return the name of the original class, not the generated class' do

data/spec/spec_helper.rb

@@ -3,25 +3,18 @@ ENV["RACK_ENV"] ||= "test"
 require 'bundler/setup'
 
 require 'cachetastic' # and any other gems you need
+require 'timecop'
 
-Spec::Runner.configure do |config|
-  
-  config.before(:all) do
-    
-  end
-  
-  config.after(:all) do
-    
-  end
-  
-  config.before(:each) do
-    
+RSpec.configure do |config|
+
+  config.before do
+    Timecop.freeze
   end
-  
-  config.after(:each) do
-    
+
+  config.after do
+    Timecop.return
   end
-  
+
 end
 
 class Cachetastic::BlockError < StandardError

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cachetastic
 version: !ruby/object:Gem::Version
-  version: 3.1.0
+  version: 3.2.0
   prerelease: 
 platform: ruby
 authors: