extract AP Page and Action caching to actionpack-deprecated_caching gem

3 files changed, 14 insertions, 399 deletions

diff --git a/actionpack/lib/action_controller/caching.rb b/actionpack/lib/action_controller/caching.rb
index fc27a0774b..c354123206 100644
--- a/actionpack/lib/action_controller/caching.rb
+++ b/actionpack/lib/action_controller/caching.rb
@@ -2,11 +2,9 @@ require 'fileutils'
 require 'uri'
 require 'set'
 
-module ActionController #:nodoc:
+module ActionController
   # \Caching is a cheap way of speeding up slow applications by keeping the result of
   # calculations, renderings, and database calls around for subsequent requests.
-  # Action Controller affords you three approaches in varying levels of granularity:
-  # Page, Action, Fragment.
   #
   # You can read more about each approach and the sweeping assistance by clicking the
   # modules below.
@@ -17,8 +15,7 @@ module ActionController #:nodoc:
   # == \Caching stores
   #
   # All the caching stores from ActiveSupport::Cache are available to be used as backends
-  # for Action Controller caching. This setting only affects action and fragment caching
-  # as page caching is always written to disk.
+  # for Action Controller caching.
   #
   # Configuration examples (MemoryStore is the default):
   #
@@ -32,9 +29,7 @@ module ActionController #:nodoc:
     extend ActiveSupport::Autoload
 
     eager_autoload do
-      autoload :Actions
       autoload :Fragments
-      autoload :Pages
       autoload :Sweeper, 'action_controller/caching/sweeping'
       autoload :Sweeping, 'action_controller/caching/sweeping'
     end
@@ -58,12 +53,23 @@ module ActionController #:nodoc:
     include AbstractController::Callbacks
 
     include ConfigMethods
-    include Pages, Actions, Fragments
+    include Fragments
     include Sweeping if defined?(ActiveRecord)
 
     included do
       extend ConfigMethods
 
+      # Most Rails requests do not have an extension, such as <tt>/weblog/new</tt>.
+      # In these cases, the page caching mechanism will add one in order to make it
+      # easy for the cached files to be picked up properly by the web server. By
+      # default, this cache extension is <tt>.html</tt>. If you want something else,
+      # like <tt>.php</tt> or <tt>.shtml</tt>, just set Base.page_cache_extension.
+      # In cases where a request already has an extension, such as <tt>.xml</tt>
+      # or <tt>.rss</tt>, page caching will not add an extension. This allows it
+      # to work well with RESTful apps.
+      config_accessor :page_cache_extension
+      self.page_cache_extension ||= '.html'
+
       config_accessor :perform_caching
       self.perform_caching = true if perform_caching.nil?
     end
diff --git a/actionpack/lib/action_controller/caching/actions.rb b/actionpack/lib/action_controller/caching/actions.rb
deleted file mode 100644
index bf16fe267c..0000000000
--- a/actionpack/lib/action_controller/caching/actions.rb
+++ /dev/null
@@ -1,189 +0,0 @@
-require 'set'
-
-module ActionController
-  module Caching
-    # Action caching is similar to page caching by the fact that the entire
-    # output of the response is cached, but unlike page caching, every
-    # request still goes through Action Pack. The key benefit of this is
-    # that filters run before the cache is served, which allows for
-    # authentication and other restrictions on whether someone is allowed
-    # to execute such action.
-    #
-    #   class ListsController < ApplicationController
-    #     before_filter :authenticate, except: :public
-    #
-    #     caches_page   :public
-    #     caches_action :index, :show
-    #   end
-    #
-    # In this example, the +public+ action doesn't require authentication
-    # so it's possible to use the faster page caching. On the other hand
-    # +index+ and +show+ require authentication. They can still be cached,
-    # but we need action caching for them.
-    #
-    # Action caching uses fragment caching internally and an around
-    # filter to do the job. The fragment cache is named according to
-    # the host and path of the request. A page that is accessed at
-    # <tt>http://david.example.com/lists/show/1</tt> will result in a fragment named
-    # <tt>david.example.com/lists/show/1</tt>. This allows the cacher to
-    # differentiate between <tt>david.example.com/lists/</tt> and
-    # <tt>jamis.example.com/lists/</tt> -- which is a helpful way of assisting
-    # the subdomain-as-account-key pattern.
-    #
-    # Different representations of the same resource, e.g.
-    # <tt>http://david.example.com/lists</tt> and
-    # <tt>http://david.example.com/lists.xml</tt>
-    # are treated like separate requests and so are cached separately.
-    # Keep in mind when expiring an action cache that
-    # <tt>action: 'lists'</tt> is not the same as
-    # <tt>action: 'list', format: :xml</tt>.
-    #
-    # You can modify the default action cache path by passing a
-    # <tt>:cache_path</tt> option. This will be passed directly to
-    # <tt>ActionCachePath.new</tt>. This is handy for actions with
-    # multiple possible routes that should be cached differently. If a
-    # block is given, it is called with the current controller instance.
-    #
-    # And you can also use <tt>:if</tt> (or <tt>:unless</tt>) to pass a
-    # proc that specifies when the action should be cached.
-    #
-    # As of Rails 3.0, you can also pass <tt>:expires_in</tt> with a time
-    # interval (in seconds) to schedule expiration of the cached item.
-    #
-    # The following example depicts some of the points made above:
-    #
-    #   class ListsController < ApplicationController
-    #     before_filter :authenticate, except: :public
-    #
-    #     caches_page :public
-    #
-    #     caches_action :index, if: Proc.new do
-    #       !request.format.json?  # cache if is not a JSON request
-    #     end
-    #
-    #     caches_action :show, cache_path: { project: 1 },
-    #       expires_in: 1.hour
-    #
-    #     caches_action :feed, cache_path: Proc.new do
-    #       if params[:user_id]
-    #         user_list_url(params[:user_id, params[:id])
-    #       else
-    #         list_url(params[:id])
-    #       end
-    #     end
-    #   end
-    #
-    # If you pass <tt>layout: false</tt>, it will only cache your action
-    # content. That's useful when your layout has dynamic information.
-    #
-    # Warning: If the format of the request is determined by the Accept HTTP
-    # header the Content-Type of the cached response could be wrong because
-    # no information about the MIME type is stored in the cache key. So, if
-    # you first ask for MIME type M in the Accept header, a cache entry is
-    # created, and then perform a second request to the same resource asking
-    # for a different MIME type, you'd get the content cached for M.
-    #
-    # The <tt>:format</tt> parameter is taken into account though. The safest
-    # way to cache by MIME type is to pass the format in the route.
-    module Actions
-      extend ActiveSupport::Concern
-
-      module ClassMethods
-        # Declares that +actions+ should be cached.
-        # See ActionController::Caching::Actions for details.
-        def caches_action(*actions)
-          return unless cache_configured?
-          options = actions.extract_options!
-          options[:layout] = true unless options.key?(:layout)
-          filter_options = options.extract!(:if, :unless).merge(:only => actions)
-          cache_options  = options.extract!(:layout, :cache_path).merge(:store_options => options)
-
-          around_filter ActionCacheFilter.new(cache_options), filter_options
-        end
-      end
-
-      def _save_fragment(name, options)
-        content = ""
-        response_body.each do |parts|
-          content << parts
-        end
-
-        if caching_allowed?
-          write_fragment(name, content, options)
-        else
-          content
-        end
-      end
-
-    protected
-      def expire_action(options = {})
-        return unless cache_configured?
-
-        if options.is_a?(Hash) && options[:action].is_a?(Array)
-          options[:action].each {|action| expire_action(options.merge(:action => action)) }
-        else
-          expire_fragment(ActionCachePath.new(self, options, false).path)
-        end
-      end
-
-      class ActionCacheFilter #:nodoc:
-        def initialize(options, &block)
-          @cache_path, @store_options, @cache_layout =
-            options.values_at(:cache_path, :store_options, :layout)
-        end
-
-        def around(controller)
-          cache_layout = @cache_layout.respond_to?(:call) ? @cache_layout.call(controller) : @cache_layout
-
-          path_options = if @cache_path.respond_to?(:call)
-            controller.instance_exec(controller, &@cache_path)
-          else
-            @cache_path
-          end
-
-          cache_path = ActionCachePath.new(controller, path_options || {})
-
-          body = controller.read_fragment(cache_path.path, @store_options)
-
-          unless body
-            controller.action_has_layout = false unless cache_layout
-            yield
-            controller.action_has_layout = true
-            body = controller._save_fragment(cache_path.path, @store_options)
-          end
-
-          body = controller.render_to_string(:text => body, :layout => true) unless cache_layout
-
-          controller.response_body = body
-          controller.content_type = Mime[cache_path.extension || :html]
-        end
-      end
-
-      class ActionCachePath
-        attr_reader :path, :extension
-
-        # If +infer_extension+ is +true+, the cache path extension is looked up from the request's
-        # path and format. This is desirable when reading and writing the cache, but not when
-        # expiring the cache - +expire_action+ should expire the same files regardless of the
-        # request format.
-        def initialize(controller, options = {}, infer_extension = true)
-          if infer_extension
-            @extension = controller.params[:format]
-            options.reverse_merge!(:format => @extension) if options.is_a?(Hash)
-          end
-
-          path = controller.url_for(options).split('://', 2).last
-          @path = normalize!(path)
-        end
-
-      private
-        def normalize!(path)
-          ext = URI.parser.escape(extension) if extension
-          path << 'index' if path[-1] == ?/
-          path << ".#{ext}" if extension and !path.split('?', 2).first.ends_with?(".#{ext}")
-          URI.parser.unescape(path)
-        end
-      end
-    end
-  end
-end
diff --git a/actionpack/lib/action_controller/caching/pages.rb b/actionpack/lib/action_controller/caching/pages.rb
deleted file mode 100644
index 3cf8d965ff..0000000000
--- a/actionpack/lib/action_controller/caching/pages.rb
+++ /dev/null
@@ -1,202 +0,0 @@
-require 'fileutils'
-require 'active_support/core_ext/class/attribute_accessors'
-
-module ActionController
-  module Caching
-    # Page caching is an approach to caching where the entire action output of is
-    # stored as a HTML file that the web server can serve without going through
-    # Action Pack. This is the fastest way to cache your content as opposed to going
-    # dynamically through the process of generating the content. Unfortunately, this
-    # incredible speed-up is only available to stateless pages where all visitors are
-    # treated the same. Content management systems -- including weblogs and wikis --
-    # have many pages that are a great fit for this approach, but account-based systems
-    # where people log in and manipulate their own data are often less likely candidates.
-    #
-    # Specifying which actions to cache is done through the +caches_page+ class method:
-    #
-    #   class WeblogController < ActionController::Base
-    #     caches_page :show, :new
-    #   end
-    #
-    # This will generate cache files such as <tt>weblog/show/5.html</tt> and
-    # <tt>weblog/new.html</tt>, which match the URLs used that would normally trigger
-    # dynamic page generation. Page caching works by configuring a web server to first
-    # check for the existence of files on disk, and to serve them directly when found,
-    # without passing the request through to Action Pack. This is much faster than
-    # handling the full dynamic request in the usual way.
-    #
-    # Expiration of the cache is handled by deleting the cached file, which results
-    # in a lazy regeneration approach where the cache is not restored before another
-    # hit is made against it. The API for doing so mimics the options from +url_for+ and friends:
-    #
-    #   class WeblogController < ActionController::Base
-    #     def update
-    #       List.update(params[:list][:id], params[:list])
-    #       expire_page action: 'show', id: params[:list][:id]
-    #       redirect_to action: 'show', id: params[:list][:id]
-    #     end
-    #   end
-    #
-    # Additionally, you can expire caches using Sweepers that act on changes in
-    # the model to determine when a cache is supposed to be expired.
-    module Pages
-      extend ActiveSupport::Concern
-
-      included do
-        # The cache directory should be the document root for the web server and is
-        # set using <tt>Base.page_cache_directory = "/document/root"</tt>. For Rails,
-        # this directory has already been set to Rails.public_path (which is usually
-        # set to <tt>Rails.root + "/public"</tt>). Changing this setting can be useful
-        # to avoid naming conflicts with files in <tt>public/</tt>, but doing so will
-        # likely require configuring your web server to look in the new location for
-        # cached files.
-        class_attribute :page_cache_directory
-        self.page_cache_directory ||= ''
-
-        # Most Rails requests do not have an extension, such as <tt>/weblog/new</tt>.
-        # In these cases, the page caching mechanism will add one in order to make it
-        # easy for the cached files to be picked up properly by the web server. By
-        # default, this cache extension is <tt>.html</tt>. If you want something else,
-        # like <tt>.php</tt> or <tt>.shtml</tt>, just set Base.page_cache_extension.
-        # In cases where a request already has an extension, such as <tt>.xml</tt>
-        # or <tt>.rss</tt>, page caching will not add an extension. This allows it
-        # to work well with RESTful apps.
-        class_attribute :page_cache_extension
-        self.page_cache_extension ||= '.html'
-
-        # The compression used for gzip. If +false+ (default), the page is not compressed.
-        # If can be a symbol showing the ZLib compression method, for example, <tt>:best_compression</tt>
-        # or <tt>:best_speed</tt> or an integer configuring the compression level.
-        class_attribute :page_cache_compression
-        self.page_cache_compression ||= false
-      end
-
-      module ClassMethods
-        # Expires the page that was cached with the +path+ as a key.
-        #
-        #   expire_page '/lists/show'
-        def expire_page(path)
-          return unless perform_caching
-          path = page_cache_path(path)
-
-          instrument_page_cache :expire_page, path do
-            File.delete(path) if File.exist?(path)
-            File.delete(path + '.gz') if File.exist?(path + '.gz')
-          end
-        end
-
-        # Manually cache the +content+ in the key determined by +path+.
-        #
-        #   cache_page "I'm the cached content", '/lists/show'
-        def cache_page(content, path, extension = nil, gzip = Zlib::BEST_COMPRESSION)
-          return unless perform_caching
-          path = page_cache_path(path, extension)
-
-          instrument_page_cache :write_page, path do
-            FileUtils.makedirs(File.dirname(path))
-            File.open(path, "wb+") { |f| f.write(content) }
-            if gzip
-              Zlib::GzipWriter.open(path + '.gz', gzip) { |f| f.write(content) }
-            end
-          end
-        end
-
-        # Caches the +actions+ using the page-caching approach that'll store
-        # the cache in a path within the +page_cache_directory+ that
-        # matches the triggering url.
-        #
-        # You can also pass a <tt>:gzip</tt> option to override the class configuration one.
-        #
-        #   # cache the index action
-        #   caches_page :index
-        #
-        #   # cache the index action except for JSON requests
-        #   caches_page :index, if: Proc.new { !request.format.json? }
-        #
-        #   # don't gzip images
-        #   caches_page :image, gzip: false
-        def caches_page(*actions)
-          return unless perform_caching
-          options = actions.extract_options!
-
-          gzip_level = options.fetch(:gzip, page_cache_compression)
-          gzip_level = case gzip_level
-          when Symbol
-            Zlib.const_get(gzip_level.upcase)
-          when Fixnum
-            gzip_level
-          when false
-            nil
-          else
-            Zlib::BEST_COMPRESSION
-          end
-
-          after_filter({:only => actions}.merge(options)) do |c|
-            c.cache_page(nil, nil, gzip_level)
-          end
-        end
-
-        private
-          def page_cache_file(path, extension)
-            name = (path.empty? || path == "/") ? "/index" : URI.parser.unescape(path.chomp('/'))
-            unless (name.split('/').last || name).include? '.'
-              name << (extension || self.page_cache_extension)
-            end
-            return name
-          end
-
-          def page_cache_path(path, extension = nil)
-            page_cache_directory.to_s + page_cache_file(path, extension)
-          end
-
-          def instrument_page_cache(name, path)
-            ActiveSupport::Notifications.instrument("#{name}.action_controller", :path => path){ yield }
-          end
-      end
-
-      # Expires the page that was cached with the +options+ as a key.
-      #
-      #   expire_page controller: 'lists', action: 'show'
-      def expire_page(options = {})
-        return unless self.class.perform_caching
-
-        if options.is_a?(Hash)
-          if options[:action].is_a?(Array)
-            options[:action].each do |action|
-              self.class.expire_page(url_for(options.merge(:only_path => true, :action => action)))
-            end
-          else
-            self.class.expire_page(url_for(options.merge(:only_path => true)))
-          end
-        else
-          self.class.expire_page(options)
-        end
-      end
-
-      # Manually cache the +content+ in the key determined by +options+. If no content is provided,
-      # the contents of response.body is used. If no options are provided, the url of the current
-      # request being handled is used.
-      #
-      #   cache_page "I'm the cached content", controller: 'lists', action: 'show'
-      def cache_page(content = nil, options = nil, gzip = Zlib::BEST_COMPRESSION)
-        return unless self.class.perform_caching && caching_allowed?
-
-        path = case options
-          when Hash
-            url_for(options.merge(:only_path => true, :format => params[:format]))
-          when String
-            options
-          else
-            request.path
-        end
-
-        if (type = Mime::LOOKUP[self.content_type]) && (type_symbol = type.symbol).present?
-          extension = ".#{type_symbol}"
-        end
-
-        self.class.cache_page(content || response.body, path, extension, gzip)
-      end
-
-    end
-  end
-end