mack-caching 0.8.1 → 0.8.2

data/lib/gems/cachetastic-2.0.0/lib/cachetastic/cacheable.rb

@@ -0,0 +1,196 @@
+module Cachetastic
+  # Include this module into an Object to achieve simplistic Object level caching.
+  # 
+  # Example:
+  #   class Person
+  #     include Cachetastic::Cacheable
+  #   
+  #     attr_accessor :name
+  #   
+  #     def cachetastic_key
+  #       self.name
+  #     end
+  #   
+  #     def always_the_same(x, y)
+  #       cacher("always_the_same") do
+  #         x + y
+  #       end
+  #     end
+  #   
+  #   end
+  module Cacheable
+    
+    module ClassAndInstanceMethods
+      # Returns the Cachetastic::Caches::Base object associated with the object.
+      # If a cache hasn't been defined the one will be created on the fly.
+      # The cache for the object is expected to be defined as:
+      # Cachetastic::Cacheable::{CLASS_NAME_HERE}Cache
+      # 
+      # Example:
+      #   class Person
+      #     include Cachetastic::Cacheable
+      #     attr_accessor :name
+      #     def cachetastic_key
+      #       self.name
+      #     end
+      #   end
+      # 
+      #  Person.cache_class # => Cachetastic::Cacheable::PersonCache
+      def cache_class
+        n = self.class.name
+        n = self.name if n == "Class"
+        # puts "n: #{n}"
+        c_name = "Cachetastic::Cacheable::#{n}Cache"
+        unless Cachetastic::Cacheable.const_defined?("#{n}Cache")
+          # puts "we need to create a cache for: #{c_name}"
+          eval %{
+            class #{c_name} < Cachetastic::Caches::Base
+            end
+          }
+        end
+        c_name.constantize
+      end
+    
+      # How much did I want to call this method cache?? It originally was that, but
+      # in Rails 2.0 they decided to use that name, so I had to rename this method.
+      # This method will attempt to get an object from the cache for a given key.
+      # If the object is nil and a block is given the block will be run, and the results
+      # of the block will be automatically cached.
+      # 
+      # Example:
+      #   class Person
+      #     include Cachetastic::Cacheable
+      #     attr_accessor :name
+      #     def cachetastic_key
+      #       self.name
+      #     end
+      #     def always_the_same(x,y)
+      #       cacher("always_the_same") do
+      #         x + y
+      #       end
+      #     end
+      #   end
+      # 
+      #   Person.new.always_the_same(1,2) # => 3
+      #   Person.new.always_the_same(2,2) # => 3
+      #   Person.new.always_the_same(3,3) # => 3
+      #   Person.cacher("always_the_same") # => 3
+      #   Person.get_from_cache("always_the_same") # => 3
+      #   Cachetastic::Cacheable::PersonCache.get("always_the_same") # => 3
+      #   
+      #   Person.cacher("say_hi") {"Hi There"} # => "Hi There"
+      #   Person.get_from_cache("say_hi") # => "Hi There"
+      #   Cachetastic::Cacheable::PersonCache.get("say_hi") # => "Hi There"
+      def cacher(key, expiry = 0)
+        cache_class.get(key) do
+          if block_given?
+            res = yield
+            cache_class.set(key, res, expiry)
+          end
+        end
+      end
+    
+      # Expires the entire cache associated with this objects's cache.
+      # 
+      # Example:
+      #   class Person
+      #     include Cachetastic::Cacheable
+      #     attr_accessor :name
+      #     def cachetastic_key
+      #       self.name
+      #     end
+      #   end
+      # 
+      #   Person.set_into_cache(1, "one")
+      #   Person.get_from_cache(1) # => "one"
+      #   Person.expire_all
+      #   Person.get_from_cache(1) # => nil
+      #   Person.set_into_cache(1, "one")
+      #   Person.get_from_cache(1) # => "one"
+      #   Cachetastic::Cacheable::PersonCache.expire_all
+      #   Person.get_from_cache(1) # => nil
+      def expire_all
+        cache_class.expire_all
+      end
+    end
+    
+    # --------------------------
+    # Instance only methods:
+    
+    # Unless the object's cachetastic_key method returns nil this method will store
+    # the object in the cache using the object's cachetastic_key as the key.
+    # You *MUST* create an instance level method called cachetastic_key and 
+    # have it return a valid key! If you return nil from the cachetastic_key method or you will not be
+    # able to use the cache_self and uncache_self methods.
+    # 
+    # Example:
+    #   class Person
+    #     include Cachetastic::Cacheable
+    #     attr_accessor :name
+    #     def cachetastic_key
+    #       self.name
+    #     end
+    #   end
+    # 
+    #   Person.get_from_cache("Mark Bates") # => nil
+    #   p = Person.new
+    #   p.name = "Mark Bates"
+    #   p.cache_self
+    #   Person.get_from_cache("Mark Bates") # => "Mark Bates"
+    def cache_self
+      cache_class.set(self.cachetastic_key, self) unless self.cachetastic_key.nil?
+    end
+
+    # Unless the object's cachetastic_key method returns nil this method will delete
+    # the object in the cache using the object's cachetastic_key as the key.
+    # You *MUST* create an instance level method called cachetastic_key and 
+    # have it return a valid key! If you return nil from the cachetastic_key method or you will not be
+    # able to use the cache_self and uncache_self methods.
+    # 
+    # Example:
+    #   class Person
+    #     include Cachetastic::Cacheable
+    #     attr_accessor :name
+    #     def cachetastic_key
+    #       self.name
+    #     end
+    #   end
+    # 
+    #   Person.get_from_cache("Mark Bates") # => nil
+    #   p = Person.new
+    #   p.name = "Mark Bates"
+    #   p.cache_self
+    #   Person.get_from_cache("Mark Bates") # => "Mark Bates"
+    #   p.uncache_self
+    #   Person.get_from_cache("Mark Bates") # => nil
+    def uncache_self
+      cache_class.delete(self.cachetastic_key) unless self.cachetastic_key.nil?
+    end
+    
+    # --------------------------
+    
+    def self.included(klass) # :nodoc:
+      klass.send(:include, ClassAndInstanceMethods)
+      klass.extend(ClassOnlyMethods)
+      klass.extend(ClassAndInstanceMethods)
+    end
+    
+    module ClassOnlyMethods
+      # Returns an object from the cache for a given key.
+      def get_from_cache(key, &block)
+        cache_class.get(key, &block)
+      end
+
+      # Deletes an object from the cache for a given key.
+      def delete_from_cache(key)
+        cache_class.delete(key)
+      end
+
+      # Sets an object into the cache for a given key.
+      def set_into_cache(key, value, expiry = 0)
+        cache_class.set(key, value, expiry)
+      end
+    end # ClassMethods
+    
+  end # Cacheable
+end # Cachetastic

data/lib/gems/cachetastic-2.0.0/lib/cachetastic/caches/base.rb

@@ -0,0 +1,238 @@
+require 'singleton'
+# When creating a new 'Cache' this class should be extended.
+# Once extended you'll only need to override just the methods
+# that are different for your cache.
+#   class MyAwesomeCache < Cachetastic::Caches::Base
+#   end
+#   MyAwesomeCache.set(1, "One")
+#   MyAwesomeCache.get(1) # => "One"
+#   MyAwesomeCache.update(1, "One!!")
+#   MyAwesomeCache.get(1) # => "One!!"
+#   MyAwesomeCache.delete(1)
+#   MyAwesomeCache.get(1) # => nil
+# 
+#   class MyAwesomeCache < Cachetastic::Caches::Base
+#     class << self
+#       def get(key)
+#         super(key) do
+#           set(key, key * 10)
+#         end
+#       end
+#     end
+#   end
+#   MyAwesomeCache.set(1, "One")
+#   MyAwesomeCache.get(1) # => "One"
+#   MyAwesomeCache.delete(1)
+#   MyAwesomeCache.get(1) # => 10
+class Cachetastic::Caches::Base
+
+  # Used to store a list of all the caches registered with the system.
+  # In order for a cache to be registered it must extend Cachetastic::Caches::Base.
+  class RegisteredCaches
+    include Singleton
+    
+    # list of all caches registered with the system.
+    attr_reader :list
+    
+    def initialize
+      @list = []
+    end
+    
+  end
+
+  # 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 a list of all registered caches in the system.
+    def all_registered_caches
+      RegisteredCaches.instance.list
+    end
+    
+    # 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 run. 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)
+      res = nil
+      do_with_logging(:get, key) do
+        retryable(:on => ArgumentError) do
+          begin
+            res = adapter.get(key.to_s)
+            if res.nil?
+              res = yield key if block_given?
+            else
+              res = unmarshall(res)
+            end
+            res
+          rescue ArgumentError => e
+            m = e.message.match(/class\/module .*/)
+            if m
+              m = m.to_s
+              m.gsub!("class/module", '')
+              m.gsub!("(ArgumentError)", '')
+              require m.strip.underscore
+              raise e
+            end
+          rescue Exception => e
+            raise e
+          end
+        end
+      end
+      res
+    end
+    
+    # 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.
+    # The default for this expiry is set as either 0, meaning it never expires, or
+    # if there's a default_expiry time set in the config file, that file will be
+    # used.
+    # If there is an expiry_swing set in the config file it will be +/- to the
+    # expiry time. See also: calculate_expiry_time
+    def set(key, value, expiry = adapter.configuration.retrieve(:default_expiry, 0))
+      do_with_logging(:set, key) do
+        expiry = calculate_expiry_time(expiry)
+        adapter.set(key.to_s, marshall(value), expiry.to_i)
+        logger.info('', '', :expiry, cache_name, key, expiry.to_i)
+        value
+      end
+    end
+    
+    alias_method :put, :set
+    
+    # Deletes an object from the cache. The optional delay parameter
+    # sets an offset, in seconds, for when the object should get deleted.
+    # The default of 0 means the object gets deleted right away.
+    def delete(key, delay = 0)
+      do_with_logging(:delete, key) do
+        adapter.delete(key.to_s, delay)
+      end
+    end
+    
+    # Expires all objects for this cache.
+    def expire_all
+      adapter.expire_all
+      logger.info('', '', :expired, cache_name)
+    end
+    
+    # Raises a MethodNotImplemented exception. This method should be overridden
+    # in the child class to enable a populating the cache with all things that
+    # should be in there. 
+    needs_method :populate_all
+    
+    # A convenience method that returns statistics for the underlying Cachetastic::Adapters::Base for the cache.
+    def stats
+      adapter.stats
+    end
+    
+    # Returns a 'methodize' version of the cache's class name. This gets used in logging,
+    # namespacing, and as the key in the Cachetastic::Connection class.
+    #   MyAwesomeCache.cache # => "my_awesome_cache"
+    #   Cachetastic::Caches::Base # => "cachetastic_caches_base"
+    def cache_name
+      self.name.methodize
+    end
+    
+    # Returns the underlying Cachetastic::Adapters::Base for this cache.
+    def adapter
+      a = cache_conn_instance.get(cache_name)
+      if adapter_supported?(a.class)
+        return a
+      else
+        raise Cachetastic::Errors::UnsupportedAdapter.new(cache_name, a.class)
+      end
+    end
+    
+    # Returns the Cachetastic::Logger for the underlying Cachetastic::Adapters::Base.
+    def logger
+      adapter.logger
+    end
+    
+    # Returns an array of unsupported adapters for this cache. Defaults to an empty
+    # array which will let any adapter be used by the cache. Override in your specific
+    # cache to prevent certain adapters.
+    def unsupported_adapters
+      []
+    end
+    
+    # Returns true/false on whether the adapter you want to use is supported for the cache.
+    def adapter_supported?(a = cache_conn_instance.get(cache_name).class)
+      return !unsupported_adapters.include?(a)
+    end
+    
+    def marshall(value)
+      return value if value.nil?
+      return case adapter.configuration.retrieve(:marshall_method, :none).to_sym
+      when :yaml
+        YAML.dump(value)
+      when :ruby
+        Marshal.dump(value)
+      else
+        value
+      end
+    end
+    
+    def unmarshall(value)
+      return value if value.nil?
+      return case adapter.configuration.retrieve(:marshall_method, :none).to_sym
+      when :yaml
+        YAML.load(value)
+      when :ruby
+        Marshal.load(value)
+      else
+        value
+      end
+    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) # :doc:
+      exp_swing = adapter.configuration.retrieve(:expiry_swing, 0)
+      if exp_swing && exp_swing != 0
+        swing = rand(exp_swing.to_i)
+        case rand(2)
+        when 0
+          expiry = (expiry.to_i + swing)
+        when 1
+          expiry = (expiry.to_i - swing)
+        end
+      end
+      expiry
+    end
+    
+    def inherited(child)
+      # puts "child: #{child.inspect}"
+      all_registered_caches << child.to_s
+      # puts "all_registered_caches: #{all_registered_caches.inspect}"
+    end
+    
+    def cache_conn_instance
+      Cachetastic::Connection.instance
+    end
+    
+    def do_with_logging(action, key)
+      start_time = Time.now
+      logger.info(:starting, action, cache_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 if adapter.debug?
+      end
+      logger.info(:finished, action, cache_name, key, (end_time - start_time), str)
+      res
+    end
+    
+    # make sure people can't instaniate this object!
+    def new(*args)
+      raise NoMethodError.new("You can not instaniate this class!")
+    end
+    
+  end
+
+end

data/lib/gems/cachetastic-2.0.0/lib/cachetastic/caches/mack_session_cache.rb

@@ -0,0 +1,3 @@
+# Used for storing Mack sessions.
+class Cachetastic::Caches::MackSessionCache < Cachetastic::Caches::Base
+end

data/lib/gems/cachetastic-2.0.0/lib/cachetastic/caches/page_cache.rb

@@ -0,0 +1,6 @@
+# Used by the Mongrel Page Cache Handler gem for page caching.
+# Future functionality may be added to this class to allow for
+# things such as deleting a certain page/set of pages based on
+# regex, etc...
+class Cachetastic::Caches::PageCache < Cachetastic::Caches::Base
+end

data/lib/gems/cachetastic-2.0.0/lib/cachetastic/caches/rails_session_cache.rb

@@ -0,0 +1,12 @@
+# Used for storing Rails sessions.
+class Cachetastic::Caches::RailsSessionCache < Cachetastic::Caches::Base
+  
+  class << self
+    
+    def unsupported_adapters
+      [Cachetastic::Adapters::File]
+    end
+    
+  end
+  
+end

data/lib/gems/cachetastic-2.0.0/lib/cachetastic/connection.rb

@@ -0,0 +1,24 @@
+# This class caches adapter objects for each cache in the system.
+class Cachetastic::Connection
+  include Singleton
+  
+  attr_accessor :connections
+  
+  def initialize
+    self.connections = {}
+  end
+  
+  # Takes the name of the cache, that's been methodized, and returns back the adapter object associated with the cache.
+  # If the adapter object doesn't exist or if the adapter is no longer valid (adapter.valid?) a new one is
+  # created and returned.
+  def get(name)
+    name = name.to_sym
+    conn = self.connections[name]
+    return conn if conn && conn.valid?
+    adapter = Cachetastic::Adapters::Base.configuration(name).adapter.to_s.camelcase
+    conn = "Cachetastic::Adapters::#{adapter}".constantize.new(name)
+    self.connections[name.to_sym] = conn
+    return conn
+  end
+  
+end

data/lib/gems/cachetastic-2.0.0/lib/cachetastic/errors/unsupported_adapter.rb

@@ -0,0 +1,7 @@
+class Cachetastic::Errors::UnsupportedAdapter < Exception
+  
+  def initialize(cache_name, adapter)
+    super("#{cache_name} does not support the use of the #{adapter} adapter!")
+  end
+  
+end

data/lib/gems/cachetastic-2.0.0/lib/cachetastic/logger.rb

@@ -0,0 +1,49 @@
+# This class handles logging for the caches and their adapters.
+class Cachetastic::Logger
+  
+  # attr_accessor :options
+  # attr_accessor :cache_name
+  attr_accessor :loggers
+  
+  def initialize(loggers)
+    @loggers = [loggers].flatten
+    # self.options = options
+    # self.cache_name = cache_name
+    # self.options.each_pair do |n, opts|
+    #   opts["level"] = (opts["level"] ||= "info").to_sym
+    # end
+  end
+  
+  LOG_LEVELS = [:fatal, :error, :warn, :info, :debug]
+  
+  LOG_LEVELS.each do |level|
+    define_method(level) do |*args|
+      lm = "[CACHE] [#{level.to_s.upcase}]\t#{Time.now.strftime("%m/%d/%y %H:%M:%S")}"
+      exs = []
+      args.each do |arg|
+        if arg.is_a?(Exception)
+          exs << arg
+          continue
+        end
+        lm << "\t" << arg.to_s 
+      end
+      exs.each do |ex|
+        lm << "\n#{ex.message}\n" << ex.backtrace.join("\n")
+      end
+      self.loggers.each do |log|
+        log.send(level, lm)
+      end
+      # self.options.each_pair do |n, opts|
+      #   if LOG_LEVELS.index(opts["level"]) >= LOG_LEVELS.index(level)
+      #     case opts["type"]
+      #     when "file"
+      #       File.open(opts["file"], "a") {|f| f.puts(lm)} 
+      #     when "console"
+      #       puts lm
+      #     end
+      #   end
+      # end
+    end
+  end
+  
+end

data/lib/gems/cachetastic-2.0.0/lib/cachetastic/rails_extensions/active_record_base.rb

@@ -0,0 +1,24 @@
+class ActiveRecord::Base
+  
+  include Cachetastic::Cacheable
+  
+  def cachetastic_key
+    self.id
+  end
+  
+  # Returns an object from the cache for a given key.
+  # If the object returned is nil and the self_populate parameter is true
+  # then the key will be used to try and find the object in the database,
+  # set the object into the cache, and then return the object.
+  def self.get_from_cache(key, self_populate = false)
+    res = cache_class.get(key)
+    if res.nil? && self_populate
+      res = self.name.constantize.find(key)
+      unless res.nil?
+        res.cache_self
+      end
+    end
+    res
+  end
+  
+end

data/lib/gems/cachetastic-2.0.0/lib/cachetastic/rails_extensions/cgi_session_store.rb

@@ -0,0 +1,59 @@
+require 'cgi'
+require 'cgi/session'
+
+class CGI #:nodoc:#
+  class Session #:nodoc:#
+    # Allows Rails to use Cachetastic for it's session store.
+    # The setting below needs to happen AFTER the gem has been required, obviously!
+    # In Rails 1.2.6 this is AFTER the initializer block.
+    #   ActionController::Base.session_store = :cachetastic_store
+    class CachetasticStore
+
+
+      def check_id(id) #:nodoc:#
+        /[^0-9a-zA-Z]+/ =~ id.to_s ? false : true
+      end
+      
+      def initialize(session, options = {}) #:nodoc:#
+        id = session.session_id
+        unless check_id(id)
+          raise ArgumentError, "session_id '%s' is invalid" % id
+        end
+        
+        @session_key = id
+        
+        @session_data = {}
+      end
+ 
+      # Restore session state from the session's memcache entry.
+      #
+      # Returns the session state as a hash.
+      def restore #:nodoc:#
+        @session_data = Cachetastic::Caches::RailsSessionCache.get(@session_key) do
+          {}
+        end
+      end
+
+      # Save session state to the session's memcache entry.
+      def update #:nodoc:#
+        Cachetastic::Caches::RailsSessionCache.set(@session_key, @session_data)
+      end
+    
+      # Update and close the session's memcache entry.
+      def close #:nodoc:#
+        update
+      end
+
+      # Delete the session's memcache entry.
+      def delete #:nodoc:#
+        Cachetastic::Caches::RailsSessionCache.delete(@session_key)
+        @session_data = {}
+      end
+      
+      def data #:nodoc:#
+        @session_data
+      end
+
+    end
+  end
+end

data/lib/gems/cachetastic-2.0.0/lib/cachetastic/ruby_extensions/object.rb

@@ -0,0 +1,8 @@
+class Object
+  
+  # Override this method in your object if you use the Cachetastic::Cacheable module.
+  def cachetastic_key
+    raise NoMethodError.new('cachetastic_key')
+  end
+  
+end