Ticket #6642: fragment_caching_for_non_erb_templates3.diff

actionpack/test/controller/caching_test.rb

@@ -25 +25 @@
-  def not_found
-    head :not_found
-  end
-
+
-  def custom_path
-    render :text => "Super soaker"
-    cache_page("Super soaker", "/index.html")
-  end
-
+
-  def expire_custom_path
-    expire_page("/index.html")
-    head :ok
-  end
-
+
-  def trailing_slash
-    render :text => "Sneak attack"
-  end
@@ -95 +95 @@
-    get :expire_custom_path
-    assert !File.exist?("#{FILE_STORE_PATH}/index.html")
-  end
-
+
-  def test_should_cache_without_trailing_slash_on_url
-    @controller.class.cache_page 'cached content', '/page_caching_test/trailing_slash'
-    assert File.exist?("#{FILE_STORE_PATH}/page_caching_test/trailing_slash.html")
@@ -215 +215 @@
-    get :index
-    assert_equal cached_time, @response.body
-  end
-
+
-  def test_action_cache_with_custom_cache_path
-    get :show
-    cached_time = content_to_cache
@@ -262 +262 @@
-    @request.host = 'jamis.hostname.com'
-    get :index
-    jamis_cache = content_to_cache
-
+
-    reset!
-
+
-    @request.host = 'david.hostname.com'
-    get :index
-    david_cache = content_to_cache
@@ -308 +308 @@
-    assert_equal 'xml', path_object.extension
-    assert_equal 'example.org/posts/index.xml', path_object.path
-  end
-
+
-  def test_correct_content_type_is_returned_for_cache_hit
-    # run it twice to cache it the first time
-    get :index, :id => 'content-type.xml'
@@ -341 +341 @@
-      @controller = ActionCachingTestController.new
-      @request.host = 'hostname.com'
-    end
-
+
-    def assert_cache_exists(path)
-      full_path = File.join(FILE_STORE_PATH, path + '.cache')
-      assert File.exist?(full_path), "#{full_path.inspect} does not exist."
-    end
-end
+
+class FragmentCachingTestController < ActionController::Base
+  def some_action; end;
+end
+
+class FragmentCachingTest < Test::Unit::TestCase
+  def setup
+    ActionController::Base.perform_caching = true
+    @store = ActionController::Caching::Fragments::UnthreadedMemoryStore.new
+    ActionController::Base.fragment_cache_store = @store
+    @controller = FragmentCachingTestController.new
+    @params = {:controller => 'posts', :action => 'index'}
+    @request = ActionController::TestRequest.new
+    @response = ActionController::TestResponse.new
+    @controller.params = @params
+    @controller.request = @request
+    @controller.response = @response
+    @controller.send(:initialize_current_url)
+  end
+
+  def test_fragement_cache_key
+    assert_equal 'what a key', @controller.fragment_cache_key('what a key')
+    assert_equal( "test.host/fragment_caching_test/some_action",
+                  @controller.fragment_cache_key(:controller => 'fragment_caching_test',:action => 'some_action'))
+  end
+
+  def test_read_fragment__with_caching_enabled
+    @store.write('name', 'value')
+    assert_equal 'value', @controller.read_fragment('name')
+  end
+
+  def test_read_fragment__with_caching_disabled
+    ActionController::Base.perform_caching = false
+    @store.write('name', 'value')
+    assert_nil @controller.read_fragment('name')
+  end
+
+  def test_write_fragment__with_caching_enabled
+    assert_nil @store.read('name')
+    assert_equal 'value', @controller.write_fragment('name', 'value')
+    assert_equal 'value', @store.read('name')
+  end
+
+  def test_write_fragment__with_caching_disabled
+    assert_nil @store.read('name')
+    ActionController::Base.perform_caching = false
+    assert_equal nil, @controller.write_fragment('name', 'value')
+    assert_nil @store.read('name')
+  end
+
+  def test_expire_fragment__with_simple_key
+    @store.write('name', 'value')
+    @controller.expire_fragment 'name'
+    assert_nil @store.read('name')
+  end
+
+  def test_expire_fragment__with__regexp
+    @store.write('name', 'value')
+    @store.write('another_name', 'another_value')
+    @store.write('primalgrasp', 'will not expire ;-)')
+
+    @controller.expire_fragment /name/
+
+    assert_nil @store.read('name')
+    assert_nil @store.read('another_name')
+    assert_equal 'will not expire ;-)', @store.read('primalgrasp')
+  end
+
+  def test_fragment_for__with_disabled_caching
+    ActionController::Base.perform_caching = false
+
+    @store.write('expensive', 'fragment content')
+    fragment_computed = false
+
+    buffer = 'generated till now -> '
+    @controller.fragment_for(Proc.new { fragment_computed = true }, 'expensive') { buffer }
+
+    assert fragment_computed
+    assert_equal 'generated till now -> ', buffer
+  end
+
+
+  def test_fragment_for
+    @store.write('expensive', 'fragment content')
+    fragment_computed = false
+
+    buffer = 'generated till now -> '
+    @controller.fragment_for(Proc.new { fragment_computed = true }, 'expensive') { buffer}
+
+    assert !fragment_computed
+    assert_equal 'generated till now -> fragment content', buffer
+  end
+
+  def test_cache_erb_fragment
+    @store.write('expensive', 'fragment content')
+    _erbout = 'generated till now -> '
+
+    assert_equal( 'generated till now -> fragment content',
+                  @controller.cache_erb_fragment(Proc.new{ }, 'expensive'))
+  end
+
+  def test_cache_rxml_fragment
+    @store.write('expensive', 'fragment content')
+    xml = 'generated till now -> '
+    class << xml; def target!; to_s; end; end
+
+    assert_equal( 'generated till now -> fragment content',
+                  @controller.cache_rxml_fragment(Proc.new{ }, 'expensive'))
+  end
+
+  def test_cache_rjs_fragment
+    @store.write('expensive', 'fragment content')
+    page = 'generated till now -> '
+
+    assert_equal( 'generated till now -> fragment content',
+                  @controller.cache_rjs_fragment(Proc.new{ }, 'expensive'))
+  end
+
+  def test_cache_rjs_fragment_debug_mode_does_not_interfere
+    @store.write('expensive', 'fragment content')
+    page = 'generated till now -> '
+
+    begin
+      debug_mode, ActionView::Base.debug_rjs = ActionView::Base.debug_rjs, true
+      assert_equal( 'generated till now -> fragment content',
+                    @controller.cache_rjs_fragment(Proc.new{ }, 'expensive'))
+      assert ActionView::Base.debug_rjs
+    ensure
+      ActionView::Base.debug_rjs = debug_mode
+    end
+  end
+end

actionpack/lib/action_controller/caching.rb

@@ -187 +187 @@
-    #     before_filter :authenticate, :except => :public
-    #     caches_page   :public
-    #     caches_action :show, :cache_path => { :project => 1 }
- 
- 
+
+
-    #         controller.send(:user_list_url, c.params[:user_id], c.params[:id]) :
-    #         controller.send(:list_url, c.params[:id]) }
-    #   end
@@ -262 +262 @@
-            controller.request.get? && controller.response.headers['Status'].to_i == 200
-          end
-      end
-
+
-      class ActionCachePath
-        attr_reader :path, :extension
-
+
-        class << self
-          def path_for(controller, options)
-            new(controller, options).path
-          end
-        end
-
+
-        def initialize(controller, options = {})
-          @extension = extract_extension(controller.request.path)
-          path = controller.url_for(options).split('://').last
@@ -279 +279 @@
-          add_extension!(path, @extension)
-          @path = URI.unescape(path)
-        end
-
+
-        private
-          def normalize!(path)
-            path << 'index' if path[-1] == ?/
-          end
-
+
-          def add_extension!(path, extension)
-            path << ".#{extension}" if extension
-          end
-
+
-          def extract_extension(file_path)
-            # Don't want just what comes after the last '.' to accommodate multi part extensions
-            # such as tar.gz.
@@ -307 +307 @@
-    #     <%= render :partial => "topic", :collection => Topic.find(:all) %>
-    #   <% end %>
-    #
- 
- 
- 
- 
+
+
+
+
-    # <tt>caches_action</tt>, so we also have the option to qualify the name of the cached fragment with something like:
-    #
-    #   <% cache(:action => "list", :action_suffix => "all_topics") do %>
-    #
- 
- 
- 
- 
+
+
+
+
-    # The expiration call for this example is:
- 
+
-    #   expire_fragment(:controller => "topics", :action => "list", :action_suffix => "all_topics")
-    #
-    # == Fragment stores
-    #
-    # By default, cached fragments are stored in memory. The available store options are:
-    #
- 
+
-    #   processes running from the same application directory to access the cached content.
-    # * MemoryStore: Keeps the fragments in memory, which is fine for WEBrick and for FCGI (if you don't care that each FCGI process holds its
-    #   own fragment store). It's not suitable for CGI as the process is thrown away at the end of each request. It can potentially also take
@@ -364 +364 @@
-        end
-      end
-
- 
+
-      # writing, or expiring a cached fragment. If the name is a hash, the generated name is the return
-      # value of url_for on that hash (without the protocol).
-      def fragment_cache_key(name)
-        name.is_a?(Hash) ? url_for(name).split("://").last : name
-      end
-
-
-cache_erb_fragment
+
+fragment_for
-        unless perform_caching then block.call; return end
-
-
-
+
-        if cache = read_fragment(name, options)
-          buffer.concat(cache)
-        else
@@ -386 +384 @@
-        end
-      end
-
+      def cache_rxml_fragment(block, name = {}, options = nil)
+        fragment_for(block, name, options) do
+          eval('xml.target!', block.binding)
+        end
+      end
+
+      # Called by CacheHelper#cache
+      def cache_rjs_fragment(block, name = {}, options = nil)
+        fragment_for(block, name, options) do
+          begin
+            debug_mode, ActionView::Base.debug_rjs = ActionView::Base.debug_rjs, false
+            eval('page.to_s', block.binding)
+          ensure
+            ActionView::Base.debug_rjs = debug_mode
+          end
+        end
+      end
+
+      # Called by CacheHelper#cache
+      def cache_erb_fragment(block, name = {}, options = nil)
+        fragment_for(block, name, options) do
+          eval(ActionView::Base.erb_variable, block.binding)
+        end
+      end
+
+
-      # Writes <tt>content</tt> to the location signified by <tt>name</tt> (see <tt>expire_fragment</tt> for acceptable formats)
-      def write_fragment(name, content, options = nil)
-        return unless perform_caching

actionpack/lib/action_view/helpers/cache_helper.rb

@@ -32 +32 @@
-      #      <i>Topics listed alphabetically</i>
-      #    <% end %>
-      def cache(name = {}, &block)
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-      end
-    end
-  end