From 438db964ad1531d3c378c3e4acc25d0007cbc1cc Mon Sep 17 00:00:00 2001 From: David Heinemeier Hansson Date: Thu, 29 Sep 2005 08:43:17 +0000 Subject: Testing should also use a default REQUEST_METHOD git-svn-id: http://svn-commit.rubyonrails.org/rails/trunk@2408 5ecf4fe2-1ee6-0310-87b1-e25e094e27de --- actionpack/lib/action_controller/caching.rb | 97 ++++++++++++++++++++--------- 1 file changed, 67 insertions(+), 30 deletions(-) (limited to 'actionpack/lib/action_controller/caching.rb') diff --git a/actionpack/lib/action_controller/caching.rb b/actionpack/lib/action_controller/caching.rb index 88529d8008..d31343dd71 100644 --- a/actionpack/lib/action_controller/caching.rb +++ b/actionpack/lib/action_controller/caching.rb @@ -57,8 +57,7 @@ module ActionController #:nodoc: # By default, the cache extension is .html, which makes it easy for the cached files to be picked up by the web server. If you want # something else, like .php or .shtml, just set Base.page_cache_extension. module Pages - def self.append_features(base) #:nodoc: - super + def self.included(base) #:nodoc: base.extend(ClassMethods) base.class_eval do @@page_cache_directory = defined?(RAILS_ROOT) ? "#{RAILS_ROOT}/public" : "" @@ -270,7 +269,7 @@ module ActionController #:nodoc: end # Called by CacheHelper#cache - def cache_erb_fragment(block, name = {}, options = {}) + def cache_erb_fragment(block, name = {}, options = nil) unless perform_caching then block.call; return end buffer = eval("_erbout", block.binding) @@ -284,33 +283,30 @@ module ActionController #:nodoc: end end - def write_fragment(name, content, options = {}) + def write_fragment(name, content, options = nil) return unless perform_caching key = fragment_cache_key(name) self.class.benchmark "Cached fragment: #{key}" do fragment_cache_store.write(key, content, options) end - content end - def read_fragment(name, options = {}) + def read_fragment(name, options = nil) return unless perform_caching - key, cache = fragment_cache_key(name), nil + key = fragment_cache_key(name) self.class.benchmark "Fragment read: #{key}" do - cache = fragment_cache_store.read(key, options) + fragment_cache_store.read(key, options) end - - cache || false end # Name can take one of three forms: # * String: This would normally take the form of a path like "pages/45/notes" # * Hash: Is treated as an implicit call to url_for, like { :controller => "pages", :action => "notes", :id => 45 } # * Regexp: Will destroy all the matched fragments, example: %r{pages/\d*/notes} - def expire_fragment(name, options = {}) + def expire_fragment(name, options = nil) return unless perform_caching key = fragment_cache_key(name) @@ -327,29 +323,58 @@ module ActionController #:nodoc: end # Deprecated -- just call expire_fragment with a regular expression - def expire_matched_fragments(matcher = /.*/, options = {}) #:nodoc: + def expire_matched_fragments(matcher = /.*/, options = nil) #:nodoc: expire_fragment(matcher, options) end - class MemoryStore #:nodoc: - def initialize - @data, @mutex = { }, Mutex.new + + class UnthreadedMemoryStore #:nodoc: + def initialize #:nodoc: + @data = {} end - def read(name, options = {}) #:nodoc: - @mutex.synchronize { @data[name] } rescue nil + def read(name, options=nil) #:nodoc: + @data[name] end - def write(name, value, options = {}) #:nodoc: - @mutex.synchronize { @data[name] = value } + def write(name, value, options=nil) #:nodoc: + @data[name] = value end - def delete(name, options = {}) #:nodoc: - @mutex.synchronize { @data.delete(name) } + def delete(name, options=nil) #:nodoc: + @data.delete(name) end - def delete_matched(matcher, options) #:nodoc: - @mutex.synchronize { @data.delete_if { |k,v| k =~ matcher } } + def delete_matched(matcher, options=nil) #:nodoc: + @data.delete_if { |k,v| k =~ matcher } + end + end + + module ThreadSafety + def read(name, options=nil) #:nodoc: + @mutex.synchronize { super } + end + + def write(name, value, options=nil) #:nodoc: + @mutex.synchronize { super } + end + + def delete(name, options=nil) #:nodoc: + @mutex.synchronize { super } + end + + def delete_matched(matcher, options=nil) #:nodoc: + @mutex.synchronize { super } + end + end + + class MemoryStore < UnthreadedMemoryStore #:nodoc: + def initialize #:nodoc: + super + if ActionController::Base.allow_concurrency + @mutex = Mutex.new + MemoryStore.send(:include, ThreadSafety) + end end end @@ -357,8 +382,9 @@ module ActionController #:nodoc: attr_reader :address def initialize(address = 'druby://localhost:9192') + super() @address = address - @data, @mutex = DRbObject.new(nil, address), Mutex.new + @data = DRbObject.new(nil, address) end end @@ -366,26 +392,27 @@ module ActionController #:nodoc: attr_reader :address def initialize(address = 'localhost') + super() @address = address - @data, @mutex = MemCache.new(address), Mutex.new + @data = MemCache.new(address) end end - class FileStore #:nodoc: + class UnthreadedFileStore #:nodoc: attr_reader :cache_path def initialize(cache_path) @cache_path = cache_path end - def write(name, value, options = {}) #:nodoc: + def write(name, value, options = nil) #:nodoc: ensure_cache_path(File.dirname(real_file_path(name))) File.open(real_file_path(name), "w+") { |f| f.write(value) } rescue => e - Base.logger.error "Couldn't create cache directory: #{name} (#{e.message})" unless Base.logger.nil? + Base.logger.error "Couldn't create cache directory: #{name} (#{e.message})" if Base.logger end - def read(name, options = {}) #:nodoc: + def read(name, options = nil) #:nodoc: IO.read(real_file_path(name)) rescue nil end @@ -427,7 +454,17 @@ module ActionController #:nodoc: end end end - end + end + + class FileStore < UnthreadedFileStore #:nodoc: + def initialize(cache_path) + super(cache_path) + if ActionController::Base.allow_concurrency + @mutex = Mutex.new + FileStore.send(:include, ThreadSafety) + end + end + end end # Sweepers are the terminators of the caching world and responsible for expiring caches when model objects change. -- cgit v1.2.3