benchmarks/cachetastic_2_benchmark.rb benchmarks/cachetastic_3_benchmark.rb lib/cachetastic/adapters/memcached.rb lib/cachetastic/cache.rb lib/cachetastic/extensions/string.rb lib/cachetastic/store_object.rb spec/cachetastic/adapters/base_spec.rb spec/cachetastic/adapters/file_spec.rb spec/cachetastic/adapters/local_memory_spec.rb spec/cachetastic/adapters/memcached_spec.rb spec/cachetastic/cache_spec.rb spec/cachetastic/cacheable_spec.rb spec/cachetastic/store_object_spec.rb spec/spec.opts spec/spec_helper.rb @@ -7,34 +7,38 @@ require 'find' require 'rubyforge' require 'rubygems' require 'rubygems/gem_runner' +require 'spec' +require 'spec/rake/spectask' @gem_spec = Gem::Specification.new do |s| - s.name = 'cachetastic' - s.version = '2.1.4' + s.name = "cachetastic-three" + s.version = "2.9.9" s.summary = "A very simple, yet very powerful caching framework for Ruby." s.description = "A very simple, yet very powerful caching framework for Ruby." - s.author = "markbates" + s.author = "Mark Bates" s.email = "mark@mackframework.com" s.homepage = "http://www.mackframework.com" - - s.test_files = FileList['test/**/*'] - - s.files = FileList['lib/**/*.rb', 'README', 'doc/**/*.*', 'bin/**/*.*'] - s.require_paths << 'lib' - - s.bindir = "bin" - s.executables << "cachetastic_drb_server" - #s.default_executable = "" - s.add_dependency("configatron", '>=2.2.2') - # s.add_dependency("mack-facets") - #s.extensions << "" + + s.files = FileList['lib/**/*.*', 'README', 'doc/**/*.*', 'bin/**/*.*'] + s.require_paths = ['lib'] s.extra_rdoc_files = ["README"] s.has_rdoc = true + s.rubyforge_project = "cachetastic" + + s.add_dependency('configatron', '>=2.3.0') + s.add_dependency('memcache-client', '>=1.5.0') + s.add_dependency('activesupport', '>=2.2.2') + # s.test_files = FileList['spec/**/*'] + #s.bindir = "bin" + #s.executables << "cachetastic" + #s.add_dependency("", "") + #s.add_dependency("", "") + #s.extensions << "" + #s.required_ruby_version = ">= 1.8.6" + #s.default_executable = "" #s.platform = "Gem::Platform::Ruby" - #s.required_ruby_version = ">= 1.8.5" #s.requirements << "An ice cold beer." #s.requirements << "Some free time!" - s.rubyforge_project = "magrathea" end # rake package @@ -45,17 +49,38 @@ Rake::GemPackageTask.new(@gem_spec) do |pkg| end # rake -desc "Run test code" -Rake::TestTask.new(:default) do |t| - t.libs << "test" - t.pattern = 'test/**/*_test.rb' - t.verbose = true +desc 'Run specifications' +Spec::Rake::SpecTask.new(:default) do |t| + opts = File.join(File.dirname(__FILE__), "spec", 'spec.opts') + t.spec_opts << '--options' << opts if File.exists?(opts) + t.spec_files = Dir.glob('spec/**/*_spec.rb') +end + +desc 'Run Rcov' +task :rcov do + unless PLATFORM['i386-mswin32'] + rcov = "rcov --sort coverage --rails --aggregate coverage.data " + + "--text-summary -Ilib -T -x gems/*,rcov*,lib/tasks/*,Rakefile,spec/*" + else + rcov = "rcov.cmd --sort coverage --rails --aggregate coverage.data " + + "--text-summary -Ilib -T" + end + system rcov + unless PLATFORM['i386-mswin32'] + system "open coverage/index.html" + end +end + +desc 'regenerate the gemspec' +task :gemspec do + @gem_spec.version = "#{@gem_spec.version}.#{Time.now.strftime('%Y%m%d%H%M%S')}" + File.open(File.join(File.dirname(__FILE__), 'cachetastic.gemspec'), 'w') {|f| f.puts @gem_spec.to_ruby} end desc "Install the gem" task :install => [:package] do |t| sudo = ENV['SUDOLESS'] == 'true' || RUBY_PLATFORM =~ /win32|cygwin/ ? '' : 'sudo' - puts `#{sudo} gem install #{File.join("pkg", @gem_spec.name)}-#{@gem_spec.version}.gem --no-update-sources` + puts `#{sudo} gem install #{File.join("pkg", @gem_spec.name)}-#{@gem_spec.version}.gem --no-update-sources --no-ri --no-rdoc` end desc "Release the gem" Rakefile @@ -1,74 +1,20 @@ -# :include: README -require 'rubygems' -require 'singleton' -require 'logger' -require 'yaml' -require 'zlib' -require 'pp' -require 'drb' require 'configatron' -# require 'mack-facets' -begin - require 'memcache' -rescue Exception => e - # if you don't have memcache installed, don't - # blow up, print a message, and you can't use - # the memcache adapter. - puts "CACHETASTIC: Warning: You don't have the memcache gem installed which means you can't use the Cachetastic::Adapters::Memcache adapter." -end - -class Object - # Uses <code>define_method</code> to create an empty for the method parameter defined. - # That method will then raise MethodNotImplemented. This is useful for creating interfaces - # and you want to stub out methods that others need to implement. - def self.needs_method(meth) - define_method(meth) do - raise NoMethodError.new("The interface you are using requires you define the following method '#{meth}'") - end - end -end +require 'logger' +require 'activesupport' +require 'fileutils' +require 'memcache' -module Cachetastic #:nodoc:# - module Caches #:nodoc:# - end - module Adapters #:nodoc:# - end - module Errors #:nodoc:# - end - module Cacheable - end +Dir.glob(File.join(File.dirname(__FILE__), 'cachetastic', '**/*.rb')).each do |f| + require File.expand_path(f) end -module ActiveRecord #:nodoc:# -end - -home = File.join(File.dirname(__FILE__), 'cachetastic') - -require File.join(home, 'connection') -require File.join(home, 'logger') -require File.join(home, 'caches/base') -require File.join(home, 'caches/page_cache') -require File.join(home, 'caches/rails_session_cache') -require File.join(home, 'caches/mack_session_cache') -require File.join(home, 'errors/unsupported_adapter') -require File.join(home, 'adapters/base') -require File.join(home, 'adapters/store_object') -require File.join(home, 'adapters/memcache') -require File.join(home, 'adapters/local_memory') -require File.join(home, 'adapters/file_base') -require File.join(home, 'adapters/file') -require File.join(home, 'adapters/html_file') -require File.join(home, 'adapters/drb') -require File.join(home, 'cacheable') -require File.join(home, 'rails_extensions/active_record_base') -require File.join(home, 'rails_extensions/cgi_session_store') -require File.join(home, 'ruby_extensions/object') -require File.join(home, 'ruby_extensions/kernel') -require File.join(home, 'ruby_extensions/string') - -configatron.cachetastic_default_options.set_default(:debug, false) -configatron.cachetastic_default_options.set_default(:adapter, :local_memory) -configatron.cachetastic_default_options.set_default(:logger, ::Logger.new(STDOUT)) -#-- -# http://rdoc.sourceforge.net/doc/index.html -#++ \ No newline at end of file +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) \ No newline at end of file lib/cachetastic.rb @@ -1,76 +1,106 @@ -# This class is the interface used to develop adapters for stores. -# Stores are where the data is actually held. These could be local memory, -# memcached, a database, the file system, etc... -# If you implement this API, then you should be able to plug in different -# stores for your caches without having to change any of your code. -# -# === Methods that need to be implemented: -# * setup - used to setup the implementation of the adapter. -# * set(key, object, expiry) - sets an object into the store using the given key and the expiry time. -# * get(key) - returns an object from the store for a given key. -# * delete(key, delay) - deletes an object from the store for a given key. If the store supports it, a delay can be used. -# * expire_all - expires all objects in the store for a given cache. -# * stats - returns statistics for the store. -# * valid? - used to test whether or not the store is still valid. If this returns false a new instance of the adapter is created by Cachetastic::Connection -class Cachetastic::Adapters::Base - - # attr_reader :all_options - # attr_reader :store_options - # attr_reader :servers - attr_reader :name - # attr_reader :logging - attr_reader :logger - - def initialize(name) - @name = name - @logger = Cachetastic::Logger.new(configuration.retrieve(:logger, ::Logger.new(STDOUT))) - setup - if self.debug? - self.logger.debug(self.name, :self, self.inspect) - end - end - - needs_method :setup - needs_method :set - needs_method :get - needs_method :delete - needs_method :expire_all - needs_method :stats - needs_method :valid? - - # Returns true/or falsed based on whether or not the debug setting is set to true in the - # configuration file. If the config setting is set, then false is returned. - def debug? - configuration.retrieve(:debug, false) - end - - def stats - cache_name = self.name.to_s.camelize - adapter_type = self.class.to_s.gsub('Cachetastic::Adapters::', '') - s = "Cache: #{cache_name}\nStore Type: #{adapter_type}\n" - if self.servers - servers = self.servers.join(',') - s += "Servers: #{servers}" - end - puts s - end - - def configuration - Cachetastic::Adapters::Base.configuration(self.name) - end - - class << self - # Returns either the options - # Options need to be specified in configatrion as the methodized name of the cache with - # _options attached at the end. - # Examples: - # Cachetastic::Caches::PageCache # => cachetastic_caches_page_cache_options - # MyAwesomeCache # => my_awesome_cache_options - def configuration(name) - name = "#{name}_options" - conf = configatron.retrieve(name, configatron.cachetastic_default_options) - conf - end - end - -end \ No newline at end of file +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 \ No newline at end of file lib/cachetastic/adapters/base.rb @@ -1,49 +1,53 @@ -# This adapter uses the file system as it's backing. -# The configuration for this should look something like this: -# my_awesome_cache_options: -# debug: false -# adapter: file -# marshall_method: none -# default_expiry: <%= 24.hours %> -# store_options: -# dir: /usr/local/caches/ -# logging: -# logger_1: -# type: file -# file: log/file_store_cache.log -class Cachetastic::Adapters::File < Cachetastic::Adapters::FileBase - - def get(key) - full_path = full_path_from_dir(get_key_directoy(key, false)) - return nil unless File.exists?(full_path) - so = YAML::load(File.open(full_path).read) - if so - if so.invalid? - self.delete(key) +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 - if so.value.is_a?(YAML::Object) - require so.value.class.underscore - so = YAML::load(File.open(full_path).read) + + 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 - return so.value - end - return nil - end - - def set(key, value, expiry = 0) - so = Cachetastic::Adapters::StoreObject.new(key.to_s, value, expiry) - File.open(full_path_from_key(key), "w") do |f| - f.puts YAML.dump(so) - end - end - - protected - def store_file_name - return STORE_FILE_NAME - end - - private - STORE_FILE_NAME = "cache.yml" - -end \ No newline at end of file + + end # File + end # Adapters +end # Cachetastic \ No newline at end of file lib/cachetastic/adapters/file.rb @@ -1,68 +1,31 @@ -# An adapter/store that keeps objects in local memory. This is great for development/testing, -# but probably shouldn't be put into production. -# It's also a very good example of how to write a adapter. -class Cachetastic::Adapters::LocalMemory < Cachetastic::Adapters::Base - - attr_accessor :local_store - - def valid? - true - end - - def setup - self.local_store = {} - end - - def expire_all - self.local_store = {} - end - - # See Cachetastic::Adapters::Base - def get(key) - so = self.local_store[key.to_s] - if so - if so.invalid? - self.delete(key) - return nil - end - return so.value - end - return nil - end - - def set(key, value, expiry = 0) - self.local_store[key.to_s] = Cachetastic::Adapters::StoreObject.new(key.to_s, value, expiry) - end - - def delete(key, delay = 0) - if delay <= 0 - self.local_store.delete(key.to_s) - else - so = self.get(key) - if so - self.set(so.key, so.value, delay) +module Cachetastic + module Adapters + class LocalMemory < Cachetastic::Adapters::Base + + def initialize(klass) + super + @_store = {} end - end - end - - def stats - super - num_keys = self.local_store.size - s = "Number of Entries: #{num_keys}\n" - if num_keys > 0 - expiries = [] - keys = [] - self.local_store.each do |key,value| - keys << key - expiries << value.expires_at - end - expiries.sort! {|x, y| x <=> y} - oldest_expiry = expiries.first - newest_expiry = expiries.last - s += "Oldest Entry: #{oldest_expiry}\nNewest Entry: #{newest_expiry}\nKeys: #{keys.inspect}\n" - end - puts s + "\n" - end - - -end \ No newline at end of file + + 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 \ No newline at end of file lib/cachetastic/adapters/local_memory.rb @@ -39,13 +39,17 @@ module Cachetastic def cache_class n = self.class.name n = self.name if n == "Class" - n.gsub!('::', '_') - c_name = "Cachetastic::Cacheable::#{n}Cache" + c_name = "Cachetastic::Cacheable::#{n.gsub('::', '_')}Cache" begin return c_name.constantize rescue NameError => e eval %{ - class #{c_name} < Cachetastic::Caches::Base + class #{c_name} < Cachetastic::Cache + + def self.cache_klass + #{n} + end + end } return c_name.constantize lib/cachetastic/cacheable.rb @@ -1,49 +1,36 @@ # This class handles logging for the caches and their adapters. -class Cachetastic::Logger +module Cachetastic + class Logger - # attr_accessor :options - # attr_accessor :cache_name - attr_accessor :loggers + # 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 + def initialize(loggers) + @loggers = [loggers].flatten + end - LOG_LEVELS = [:fatal, :error, :warn, :info, :debug] + 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 + 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 - 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 \ No newline at end of file + end # Logger +end # Cachetastic \ No newline at end of file lib/cachetastic/logger.rb bin/cachetastic_drb_server lib/cachetastic/adapters/drb.rb lib/cachetastic/adapters/file_base.rb lib/cachetastic/adapters/html_file.rb lib/cachetastic/adapters/memcache.rb lib/cachetastic/adapters/store_object.rb lib/cachetastic/caches/base.rb lib/cachetastic/caches/mack_session_cache.rb lib/cachetastic/caches/page_cache.rb lib/cachetastic/caches/rails_session_cache.rb lib/cachetastic/connection.rb lib/cachetastic/errors/unsupported_adapter.rb lib/cachetastic/rails_extensions/active_record_base.rb lib/cachetastic/rails_extensions/cgi_session_store.rb lib/cachetastic/ruby_extensions/kernel.rb lib/cachetastic/ruby_extensions/object.rb lib/cachetastic/ruby_extensions/string.rb lib/tasks/cachetastic_tasks.rake lib/tasks/rubyforge_config.yml test/active_record_test.rb test/cacheable_test.rb test/cachetastic_unit_test.rb test/config.rb test/drb_adapter_test.rb test/file_adapter_test.rb test/memcache_adapter_test.rb test/test_helper.rb 353b8e4ca20821b08ee90932af9908f470334d49 ea2311163bab25300c319094cd9de4dafc5f0353 Mark Bates mark@markbates.com http://github.com/markbates/cachetastic/commit/62e5ea74011b2df3b0fa09abf8791cef388653e6 62e5ea74011b2df3b0fa09abf8791cef388653e6 2009-05-20T11:31:42-07:00 2009-05-20T11:31:42-07:00 Merge in the pending 3.0 changes. Conflicts: .gitignore README Rakefile lib/cachetastic.rb lib/cachetastic/adapters/base.rb lib/cachetastic/adapters/file.rb lib/cachetastic/adapters/local_memory.rb lib/cachetastic/cacheable.rb lib/cachetastic/logger.rb e6d454c597849e1004e15e0408b6003609385497 Mark Bates mark@markbates.com