markbates-cachetastic-three 2.9.9.20090525090948

data/README

@@ -0,0 +1,75 @@
+=Configuration:
+
+    # this will dump into the log, configuration info for each cache, as well as the .inspect
+    # for each object returned from the cache
+    configatron.cachetastic_default_options.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
+    configatron.cachetastic_default_options.adapter = :local_memory # local_memory | memcache | file | drb | html_file (default: local_memory)
+
+    # this will marshall objects into and out of the store.
+    configatron.cachetastic_default_options.marshall_method = :none # none | yaml | ruby (default: none)
+
+    # this sets how long objects will live in the cache before they are auto expired.
+    configatron.cachetastic_default_options.default_expiry = 86400 # time in seconds (default: 24 hours)
+
+    # when setting objects into the cache the expiry_swing is +/- to the expiry time.
+    # example: if the expiry time is 1 hour, and the swing is 15 minutes,
+    # objects will go into the cache with an expiry time sometime between 45 mins and 75 mins.
+    configatron.cachetastic_default_options.expiry_swing = 60 * 15 # time in seconds (default: 0)
+
+    # these options get passed on directly to the store.
+    # listed below are options for memcache:
+    configatron.cachetastic_default_options.store_options.c_threshold = "10_000"
+    configatron.cachetastic_default_options.store_options.compression = true
+    configatron.cachetastic_default_options.store_options.debug = false
+    configatron.cachetastic_default_options.store_options.readonly = false
+    configatron.cachetastic_default_options.store_options.urlencode = false
+    
+    # set the servers to be used for memcache
+    configatron.cachetastic_default_options.servers = ["127.0.0.1:11211"] # ip:port used for memcache
+
+    # listed below are the options for file:
+    configatron.cachetastic_default_options.store_options.dir = "/cachetastic/caches"
+
+    # listed below are the options for drb:
+    configatron.cachetastic_default_options.servers = ["druby://127.0.0.1:61676"]
+
+    # configure logging for this cache
+    # 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_default_options.logger = [log_1, log_2]
+
+=Cachetastic::Drb::Server
+If you want to use Drb and the Cachetastic::Adapters::Drb adapter, you'll have to use the Cachetastic::Drb::Server that comes with Cachetastic. Using this server is simple. It gets installed as a binary when you install the Cachetastic gem.
+
+  $ cachetastic_drb_server # that will start the drb server on the host 127.0.0.1 on the port 61676
+  
+The server takes to command line parameters: -h <host> -p <port> -v <verbose> -rv <really verbose>
+    
+=Examples:
+
+  class MyAwesomeCache < Cachetastic::Caches::Base
+  end
+  
+  MyAwesomeCache.set(1, [1,2,3])
+  MyAwesomeCache.get(1) # => [1,2,3] 
+  
+  class MyAwesomeCache < Cachetastic::Caches::Base
+    class << self
+      def get(key, x, y)
+        super(key) do
+          n = x + y
+          set(key, n)
+          n
+        end
+      end
+    end
+  end
+  
+  MyAwesomeCache.get(1, 2, 4) # => 8
+  MyAwesomeCache.get(1, 4, 4) # => 8

data/lib/cachetastic.rb

@@ -0,0 +1,20 @@
+require 'configatron'
+require 'logger'
+require 'activesupport'
+require 'fileutils'
+require 'memcache'
+
+Dir.glob(File.join(File.dirname(__FILE__), 'cachetastic', '**/*.rb')).each do |f|
+  require File.expand_path(f)
+end
+
+configatron.cachetastic.defaults.set_default(:marshal_method, :none)
+configatron.cachetastic.defaults.set_default(:expiry_swing, 0)
+configatron.cachetastic.defaults.set_default(:default_expiry, 86400)
+configatron.cachetastic.defaults.set_default(:debug, true)
+configatron.cachetastic.defaults.set_default(:adapter, Cachetastic::Adapters::LocalMemory)
+log_path = File.join(FileUtils.pwd, 'log', 'cachetastic.log')
+FileUtils.mkdir_p(File.dirname(log_path))
+logger = ::Logger.new(log_path)
+logger.level = ::Logger::DEBUG
+configatron.cachetastic.defaults.set_default(:logger, logger)

data/lib/cachetastic/adapters/base.rb

@@ -0,0 +1,106 @@
+module Cachetastic
+  module Adapters
+    
+    class << self
+      
+      def build(klass)
+        adp = klass.to_configatron(:cachetastic).adapter
+        if adp.nil?
+          adp = configatron.cachetastic.defaults.adapter
+        end
+        adp.new(klass)
+      end
+      
+    end # class << self
+    
+    class Base
+      
+      attr_accessor :klass
+      
+      def initialize(klass)
+        self.klass = klass
+        configatron.cachetastic.defaults.configatron_keys.each do |key|
+          define_accessor(key)
+          self.send("#{key}=", configatron.cachetastic.defaults.send(key))
+        end
+        klass.to_configatron(:cachetastic).configatron_keys.each do |key|
+          define_accessor(key)
+          self.send("#{key}=", klass.to_configatron(:cachetastic).send(key))
+        end
+      end
+      
+      # Allows an adapter to transform the key
+      # to a safe representation for it's backend.
+      # For example, the key: '$*...123()%~q' is not a 
+      # key for the file system, so the 
+      # Cachetastic::Adapters::File class should override
+      # this to make it safe for the file system.
+      def transform_key(key)
+        key
+      end
+      
+      def valid?
+        true
+      end
+      
+      def debug?
+        return self.debug if self.respond_to?(:debug)
+        return false
+      end
+      
+      def marshal(value)
+        return nil if value.nil?
+        case self.marshal_method.to_sym
+        when :yaml
+          return YAML.dump(value)
+        when :ruby
+          return Marshal.dump(value)
+        else
+          return value
+        end
+      end
+      
+      def unmarshal(value)
+        return nil if value.nil?
+        case self.marshal_method.to_sym
+        when :yaml
+          return YAML.load(value)
+        when :ruby
+          return Marshal.load(value)
+        else
+          return 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_time) # :doc:
+        expiry_time = self.default_expiry if expiry_time.nil?
+        exp_swing = self.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
+        end
+        expiry_time
+      end
+      
+      def define_accessor(key)
+        instance_eval(%{
+          def #{key}
+            @#{key}
+          end
+          def #{key}=(x)
+            @#{key} = x
+          end
+        })        
+      end
+      
+    end # Base
+  end # Adapters
+end # Cachetastic

data/lib/cachetastic/adapters/file.rb

@@ -0,0 +1,53 @@
+module Cachetastic
+  module Adapters
+    class File < Cachetastic::Adapters::Base
+      
+      def initialize(klass)
+        define_accessor(:storage_path)
+        self.storage_path = ::File.join(FileUtils.pwd, 'cachetastic')
+        super
+        self.marshal_method = :yaml if self.marshal_method == :none
+        @_file_paths = {}
+      end
+      
+      def get(key, &block)
+        path = file_path(key)
+        val = nil
+        val = ::File.read(path) if ::File.exists?(path)
+        return val
+      end # get
+      
+      def set(key, value, expiry_time = nil)
+        so = Cachetastic::Cache::StoreObject.new(key, value, calculate_expiry_time(expiry_time).from_now)
+        path = file_path(key)
+        ::File.open(path, 'w') {|f| f.write marshal(so)}
+        value
+      end # set
+      
+      def delete(key)
+        FileUtils.rm(file_path(key))
+      end # delete
+      
+      def expire_all
+        @_file_paths = {}
+        ::FileUtils.rm_rf(::File.join(self.storage_path, klass.name.underscore))
+        return nil
+      end # expire_all
+      
+      def transform_key(key)
+        key.to_s.hexdigest
+      end
+      
+      def file_path(key)
+        path = @_file_paths[key]
+        if path.nil?
+          path = ::File.join(self.storage_path, klass.name.underscore, transform_key(key).scan(/(.{1,4})/).flatten, 'cache.data')
+          @_file_paths[key] = path
+          FileUtils.mkdir_p(::File.dirname(path))
+        end
+        return path
+      end
+      
+    end # File
+  end # Adapters
+end # Cachetastic

data/lib/cachetastic/adapters/local_memory.rb

@@ -0,0 +1,31 @@
+module Cachetastic
+  module Adapters
+    class LocalMemory < Cachetastic::Adapters::Base
+      
+      def initialize(klass)
+        super
+        @_store = {}
+      end
+      
+      def get(key, &block)
+        @_store[key]
+      end # get
+      
+      def set(key, value, expiry_time = nil)
+        so = Cachetastic::Cache::StoreObject.new(key, value, calculate_expiry_time(expiry_time).from_now)
+        @_store[key] = marshal(so)
+        value
+      end # set
+      
+      def delete(key)
+        @_store.delete(key)
+      end # delete
+      
+      def expire_all
+        @_store = {}
+        return nil
+      end # expire_all
+      
+    end # LocalMemory
+  end # Adapters
+end # Cachetastic

data/lib/cachetastic/adapters/memcached.rb

@@ -0,0 +1,93 @@
+module Cachetastic
+  module Adapters
+    class Memcached < Cachetastic::Adapters::Base
+      
+      def initialize(klass)
+        # puts "initialize: #{klass}"
+        define_accessor(:servers)
+        define_accessor(:mc_options)
+        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}
+        super
+        connection
+      end
+      
+      def get(key, &block)
+        connection.get(transform_key(key), false)
+      end # get
+      
+      def set(key, value, expiry_time = 0)
+        connection.set(transform_key(key), marshal(value), calculate_expiry_time(expiry_time), false)
+      end # set
+      
+      def delete(key)
+        connection.delete(transform_key(key), self.delete_delay)
+      end # delete
+      
+      def expire_all
+        increment_version
+        @_mc_connection = nil
+        return nil
+      end # expire_all
+      
+      def transform_key(key)
+        key.to_s.hexdigest
+      end
+      
+      def valid?
+        return false if @_mc_connection.nil?
+        return false unless @_mc_connection.active?
+        return true
+      end
+      
+      private
+      def connection
+        unless @_mc_connection && valid? && @_ns_version == get_version
+          @_mc_connection = MemCache.new(self.servers, self.mc_options.merge(:namespace => namespace))
+        end
+        @_mc_connection
+      end
+      
+      def ns_connection
+        unless @_ns_connection
+          @_ns_connection = MemCache.new(self.servers, self.mc_options.merge(:namespace => :namespace_versions))
+        end
+        @_ns_connection
+      end
+      
+      def increment_version
+        name = self.klass.name
+        v = get_version
+        ns_connection.set(name, v + 1)
+      end
+
+      def get_version
+        name = self.klass.name
+        v = ns_connection.get(name)
+        if v.nil?
+          ns_connection.set(name, 1)
+          v = 1
+        end
+        v
+      end
+      
+      def namespace
+        @_ns_version = get_version
+        "#{self.klass.name}.#{@_ns_version}"
+      end
+      
+    end # Memcached
+  end # Adapters
+end # Cachetastic
+
+#      c_threshold: 10_000
+#      compression: true
+#      debug: false
+#      readonly: false
+#      urlencode: false

data/lib/cachetastic/cache.rb

@@ -0,0 +1,99 @@
+module Cachetastic
+  class Cache
+    
+    class << self
+      
+      def get(key, &block)
+        do_with_logging(:get, key) do
+          val = self.adapter.get(key, &block)
+          handle_store_object(key, adapter.unmarshal(val), &block)
+        end
+      end # get
+      
+      def set(key, value, expiry_time = nil)
+        do_with_logging(:set, key) do
+          self.adapter.set(key, value, expiry_time)
+        end
+      end # set
+      
+      def delete(key)
+        do_with_logging(:delete, key) do
+          self.adapter.delete(key)
+          nil
+        end
+      end # delete
+      
+      def expire_all
+        do_with_logging(:expire_all, nil) do
+          self.adapter.expire_all
+          nil
+        end
+      end # expire_all
+      
+      def adapter
+        unless @_adapter && @_adapter.valid?
+          @_adapter = Cachetastic::Adapters.build(cache_klass)
+        end
+        @_adapter
+      end # adapter
+      
+      def clear_adapter!
+        @_adapter = nil
+      end
+      
+      def cache_klass
+        self
+      end
+      
+      def logger
+        unless @_logger
+          @_logger = Cachetastic::Logger.new(adapter.logger)
+        end
+        @_logger
+      end
+      
+      private
+      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?
+        end
+        return val unless val.nil?
+        
+        val = yield 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 if block_given?
+        end
+      end
+      
+    end # class << self
+    
+  end # Cache
+end # Cachetastic

data/lib/cachetastic/cacheable.rb

@@ -0,0 +1,202 @@
+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"
+        c_name = "Cachetastic::Cacheable::#{n.gsub('::', '_')}Cache"
+        begin
+          return c_name.constantize
+        rescue NameError => e
+          eval %{
+            class #{c_name} < Cachetastic::Cache
+              
+              def self.cache_klass
+                #{n}
+              end
+              
+            end
+          }
+          return c_name.constantize
+        end
+        
+      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/cachetastic/extensions/string.rb

@@ -0,0 +1,8 @@
+require 'digest'
+class String # :nodoc:
+  
+  def hexdigest # :nodoc:
+    Digest::SHA1.hexdigest(self)
+  end
+  
+end

data/lib/cachetastic/logger.rb

@@ -0,0 +1,37 @@
+# This class handles logging for the caches and their adapters.
+module Cachetastic
+  class Logger
+  
+    # attr_accessor :options
+    # attr_accessor :cache_name
+    attr_accessor :loggers
+  
+    def initialize(*loggers)
+      @loggers = [loggers].flatten
+    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
+        # puts "lm: #{lm}"
+        self.loggers.each do |log|
+          log.send(level, lm)
+        end
+      end
+    end
+  
+  end # Logger
+end # Cachetastic

data/lib/cachetastic/store_object.rb

@@ -0,0 +1,22 @@
+module Cachetastic
+  class Cache
+    
+    class StoreObject # :nodoc:
+      attr_accessor :expires_at
+      attr_accessor :key
+      attr_accessor :value
+      
+      def initialize(key, value, expires_at)
+        self.key = key
+        self.value = value
+        self.expires_at = expires_at
+      end
+      
+      def expired?
+        return Time.now > self.expires_at
+      end
+      
+    end # StoreObject
+    
+  end # Cache
+end # Cachetastic

metadata

@@ -0,0 +1,92 @@
+--- !ruby/object:Gem::Specification 
+name: markbates-cachetastic-three
+version: !ruby/object:Gem::Version 
+  version: 2.9.9.20090525090948
+platform: ruby
+authors: 
+- Mark Bates
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-05-25 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: configatron
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.3.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: memcache-client
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.5.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: activesupport
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.2.2
+    version: 
+description: A very simple, yet very powerful caching framework for Ruby.
+email: mark@mackframework.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- lib/cachetastic/adapters/base.rb
+- lib/cachetastic/adapters/file.rb
+- lib/cachetastic/adapters/local_memory.rb
+- lib/cachetastic/adapters/memcached.rb
+- lib/cachetastic/cache.rb
+- lib/cachetastic/cacheable.rb
+- lib/cachetastic/extensions/string.rb
+- lib/cachetastic/logger.rb
+- lib/cachetastic/store_object.rb
+- lib/cachetastic.rb
+- README
+has_rdoc: true
+homepage: http://www.mackframework.com
+post_install_message: 
+rdoc_options: []
+
+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: cachetastic
+rubygems_version: 1.2.0
+signing_key: 
+specification_version: 2
+summary: A very simple, yet very powerful caching framework for Ruby.
+test_files: []
+