interlock 1.0 → 1.1

data/CHANGELOG

@@ -1,2 +1,4 @@
 
+v1.1. Add :perform => false option. Cache :content_for. Test nested view_cache blocks. Don't assign conventional dependency when called from the view, because we don't know what the controller might have already specified.
+
 v1.0. First release.

data/Manifest

@@ -12,6 +12,7 @@ lib/interlock.rb
 LICENSE
 Manifest
 README
+tasks/interlock.rake
 test/integration/app/app/controllers/application.rb
 test/integration/app/app/controllers/eval_controller.rb
 test/integration/app/app/controllers/items_controller.rb
@@ -19,10 +20,12 @@ test/integration/app/app/helpers/application_helper.rb
 test/integration/app/app/helpers/eval_helper.rb
 test/integration/app/app/helpers/items_helper.rb
 test/integration/app/app/models/item.rb
-test/integration/app/app/views/items/list.html.erb
-test/integration/app/app/views/items/recent.html.erb
-test/integration/app/app/views/items/show.html.erb
-test/integration/app/app/views/shared/_related.html.erb
+test/integration/app/app/views/items/detail.rhtml
+test/integration/app/app/views/items/list.rhtml
+test/integration/app/app/views/items/recent.rhtml
+test/integration/app/app/views/items/show.rhtml
+test/integration/app/app/views/layouts/application.html.erb
+test/integration/app/app/views/shared/_related.rhtml
 test/integration/app/config/boot.rb
 test/integration/app/config/database.yml
 test/integration/app/config/environment.rb
@@ -33,18 +36,7 @@ test/integration/app/config/initializers/inflections.rb
 test/integration/app/config/initializers/mime_types.rb
 test/integration/app/config/memcached.yml
 test/integration/app/config/routes.rb
-test/integration/app/coverage/cache-43041
-test/integration/app/coverage/index.html
-test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-action_controller_rb.html
-test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-action_view_rb.html
-test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-active_record_rb.html
-test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-config_rb.html
-test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-core_extensions_rb.html
-test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-interlock_rb.html
-test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-memcached_rb.html
-test/integration/app/coverage/vendor-plugins-interlock-lib-interlock_rb.html
 test/integration/app/db/migrate/001_create_items.rb
-test/integration/app/db/schema.rb
 test/integration/app/doc/README_FOR_APP
 test/integration/app/public/404.html
 test/integration/app/public/422.html
@@ -85,5 +77,6 @@ test/integration/server_test.rb
 test/setup.rb
 test/teardown.rb
 test/test_helper.rb
+test/unit/interlock_test.rb
 test/unit/memcached_test.rb
 TODO

data/README

@@ -1,7 +1,7 @@
 
 Interlock
 
-An optimal-efficiency caching plugin for Rails.
+A Rails plugin for maintainable and high-efficiency caching.
 
 == License
 
@@ -11,14 +11,17 @@ The public certificate for the gem is at http://rubyforge.org/frs/download.php/2
 
 == Requirements
 
-* Memcached (http://www.danga.com/memcached)
+* memcached (http://www.danga.com/memcached)
 * memcache-client gem
+* Rails 1.2.6
+
+Note that Rails 2.0.2 is required for caching <tt>content_for</tt> or nesting <tt>view_cache</tt> blocks.
 
 == What it does
 
 Interlock makes your view fragments and associated controller blocks march along together. If a fragment is fresh, the controller behavior won't run. This eliminates duplicate effort from your request cycle. Your controller blocks run so infrequently that you can use regular ActiveRecord finders and not worry about object caching at all.
 
-Interlock automatically tracks invalidation dependencies based on the model lifecyle, and supports arbitrary levels of  scoping per-block.
+Interlock automatically tracks invalidation dependencies based on the model lifecyle, and supports arbitrary levels of scoping per-block. It also caches <tt>content_for</tt> calls, unlike regular Rails.
 
 == Installation
   
@@ -47,7 +50,7 @@ Now you're ready to go.
  
 == Usage
 
-Interlock provides two similar caching methods: <tt>behavior_cache</tt> for controllers and <tt>view_cache</tt> for views. The both accept an optional list or hash of model dependencies, and an optional <tt>:tag</tt> keypair. <tt>view_cache</tt> also accepts a <tt>ttl</tt>.
+Interlock provides two similar caching methods: <tt>behavior_cache</tt> for controllers and <tt>view_cache</tt> for views. They both accept an optional list or hash of model dependencies, and an optional <tt>:tag</tt> keypair. <tt>view_cache</tt> also accepts a <tt>:ttl</tt> keypair.
 
 The simplest usage doesn't require any parameters. In the controller:
 
@@ -61,7 +64,7 @@ The simplest usage doesn't require any parameters. In the controller:
     
   end
   
-Now, in the view, wrap the largest section of ERB you can find that uses data from <tt>@items</tt> (but not from any other instance variables) in a <tt>view_cache</tt> block. 
+Now, in the view, wrap the largest section of ERB you can find that uses data from <tt>@items</tt> in a <tt>view_cache</tt> block. No other part of the view can refer to <tt>@items</tt>, because <tt>@items</tt> won't get set unless the cache is stale.
 
   <% @title = "My Sweet Items" %>
 
@@ -77,74 +80,9 @@ This automatically registers a caching dependency on Item for <tt>slow_action</t
 
 You can use multiple instance variables in one block, of course. Just make sure the <tt>behavior_cache</tt> provides whatever the <tt>view_cache</tt> uses.
 
-== Declaring dependencies
-
-You can declare non-default invalidation dependencies by passing models to <tt>behavior_cache</tt> (you can also pass them to <tt>view_cache</tt>, but you should only do that if you are caching a fragment without an associated behavior block in the controller).
-
-<b>No dependencies (cache never invalidates):</b>
-  behavior_cache nil do
-  end
-  
-<b>Invalidate on any Media change:</b>
-  behavior_cache Media do
-  end
-  
-<b>Invalidate on any Media or Item change:</b>
-  behavior_cache Media, Item do
-  end
-  
-<b>Invalidate on Item changes if the Item <tt>id</tt> matches the current <tt>params[:id]</tt> value:</b>
-  behavior_cache Item => :id do
-  end
-
-You do not have to pass the same dependencies to <tt>behavior_cache</tt> and <tt>view_cache</tt> even for the same action. The set union of both dependency lists will be used.
-
-== Narrowing scope and caching multiple blocks
-
-Sometimes you need to cache multiple blocks in a controller, or otherwise get a more fine-grained scope. Interlock provides the <tt>:tag</tt> key for this purpose. <tt>:tag</tt> accepts either an array of symbols, which are mapped to <tt>params</tt> values, or an arbitrary object, which is converted to a string identifier. <b>Your corresponding behavior caches and view caches must have identical <tt>:tag</tt> values for the interlocking to take effect.</b>
-
-Note that <tt>:tag</tt> can be used to scope caches. You can simultaneously cache different versions of the same block, differentiating based on params or other logic. This is great for caching per-user, for example:
-
-  def profile
-    @user = current_user
-    behavior_cache :tag => @user do
-      @items = Item.find(:all, :conditions => "be slow")
-    end
-  end
-
-In the view, use the same <tt>:tag</tt> value (<tt>@user</tt>). Note that <tt>@user</tt> must be set outside of the behavior block in the controller, because its contents are used to decide whether to run the block in the first place.
-
-This way each user will see only their own cache. Pretty neat.
-
-== Broadening scope
-
-Sometimes the default scope (<tt>controller</tt>, <tt>action</tt>, <tt>params[:id]</tt>) is too narrow. For example, you might share a partial across actions, and set up its data via a filter. By default, Interlock will cache a separate version of it for each action. To avoid this, you can use the <tt>:ignore</tt> key, which lets you list parts of the default scope to ignore:
-
-  before_filter :recent
-  
-  private
-  
-  def recent
-    behavior_cache :ignore => :action do
-      @recent = Item.find(:all, :limit => 5, :order => 'updated_at DESC')
-    end
-  end
-
-Valid values for <tt>:ignore</tt> are <tt>:controller</tt>, <tt>:action</tt>, <tt>:id</tt>, and <tt>:all</tt>. You can pass an array of multiple values. <b>Just like with <tt>:tag</tt>, your corresponding behavior caches and view caches must have identical <tt>:ignore</tt> values.</b> Note that cache blocks with <tt>:ignore</tt> values still obey the regular invalidation rules.
-
-A good way to get started is to just use the default scope. Then <tt>grep</tt> in the production log for <tt>interlock</tt> and see what keys are being set and read. If you see lots of different keys go by for data that you know is the same, then set some <tt>:ignore</tt> values. 
+See ActionController::Base and ActionView::Helpers::CacheHelper for more details.
 
-== View-only caching
-
-It's fine to use a <tt>view_cache</tt> block without a <tt>behavior_cache</tt> block. For example, to mimic regular fragment cache behavior, but take advantage of Memcached's <tt>:ttl</tt> support, call:
-
-  <% view_cache nil, :ignore => :all, :tag => 'sidebar', :ttl => 5.minutes %>
-    <h1>On the side</h1>
-  <% end %> 
-  
-Remember that <tt>nil</tt> disables invalidation rules. This is a nice trick for keeping your caching strategy unified.
-
-== Gotchas
+== Notes
 
 You will not see any actual cache reuse in development mode unless you set <tt>config.action_controller.perform_caching = true</tt> in <tt>config/environments/development.rb</tt>.
 
@@ -161,8 +99,13 @@ You can write custom invalidation rules if you really want to, but try hard to a
 
 Also, Interlock obeys the <tt>ENV['RAILS_ASSET_ID']</tt> setting, so if you need to blanket-invalidate all your caches, just change <tt>RAILS_ASSET_ID</tt> (for example, you could have it increment on every deploy).
 
+== Further resources
+
+* http://blog.evanweaver.com/articles/2007/12/13/better-rails-caching/
+* http://www.socialtext.net/memcached/index.cgi?faq
+
 == Reporting problems
 
-* http://rubyforge.org/forum/forum.php?forum_id=18926
+* http://rubyforge.org/forum/forum.php?forum_id=19835
 
 Patches and contributions are very welcome. Please note that contributors are required to assign copyright for their additions to Cloudburst, LLC. 

data/TODO

@@ -1,3 +1,6 @@
 
+* Add test coverage of STI child classes
+* Add anti-dogpiling logic
+* Possibly memoize single-id finders, either per-action or globally with automatic invalidations
 * Figure out how to cache Builder blocks
 * Figure out how to cache RJS

data/interlock.gemspec

@@ -1,26 +1,26 @@
 
-# Gem::Specification for Interlock-1.0
+# Gem::Specification for Interlock-1.1
 # Originally generated by Echoe
 
 Gem::Specification.new do |s|
   s.name = %q{interlock}
-  s.version = "1.0"
+  s.version = "1.1"
 
   s.specification_version = 2 if s.respond_to? :specification_version=
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = [""]
-  s.date = %q{2007-12-13}
-  s.description = %q{An optimal-efficiency caching plugin for Rails.}
+  s.date = %q{2008-01-15}
+  s.description = %q{A Rails plugin for maintainable and high-efficiency caching.}
   s.email = %q{}
-  s.files = ["CHANGELOG", "examples/memcached.yml", "init.rb", "lib/interlock/action_controller.rb", "lib/interlock/action_view.rb", "lib/interlock/active_record.rb", "lib/interlock/config.rb", "lib/interlock/core_extensions.rb", "lib/interlock/interlock.rb", "lib/interlock/memcached.rb", "lib/interlock.rb", "LICENSE", "Manifest", "README", "test/integration/app/app/controllers/application.rb", "test/integration/app/app/controllers/eval_controller.rb", "test/integration/app/app/controllers/items_controller.rb", "test/integration/app/app/helpers/application_helper.rb", "test/integration/app/app/helpers/eval_helper.rb", "test/integration/app/app/helpers/items_helper.rb", "test/integration/app/app/models/item.rb", "test/integration/app/app/views/items/list.html.erb", "test/integration/app/app/views/items/recent.html.erb", "test/integration/app/app/views/items/show.html.erb", "test/integration/app/app/views/shared/_related.html.erb", "test/integration/app/config/boot.rb", "test/integration/app/config/database.yml", "test/integration/app/config/environment.rb", "test/integration/app/config/environments/development.rb", "test/integration/app/config/environments/production.rb", "test/integration/app/config/environments/test.rb", "test/integration/app/config/initializers/inflections.rb", "test/integration/app/config/initializers/mime_types.rb", "test/integration/app/config/memcached.yml", "test/integration/app/config/routes.rb", "test/integration/app/coverage/cache-43041", "test/integration/app/coverage/index.html", "test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-action_controller_rb.html", "test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-action_view_rb.html", "test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-active_record_rb.html", "test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-config_rb.html", "test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-core_extensions_rb.html", "test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-interlock_rb.html", "test/integration/app/coverage/vendor-plugins-interlock-lib-interlock-memcached_rb.html", "test/integration/app/coverage/vendor-plugins-interlock-lib-interlock_rb.html", "test/integration/app/db/migrate/001_create_items.rb", "test/integration/app/db/schema.rb", "test/integration/app/doc/README_FOR_APP", "test/integration/app/public/404.html", "test/integration/app/public/422.html", "test/integration/app/public/500.html", "test/integration/app/public/dispatch.cgi", "test/integration/app/public/dispatch.fcgi", "test/integration/app/public/dispatch.rb", "test/integration/app/public/favicon.ico", "test/integration/app/public/images/rails.png", "test/integration/app/public/index.html", "test/integration/app/public/javascripts/application.js", "test/integration/app/public/javascripts/controls.js", "test/integration/app/public/javascripts/dragdrop.js", "test/integration/app/public/javascripts/effects.js", "test/integration/app/public/javascripts/prototype.js", "test/integration/app/public/robots.txt", "test/integration/app/Rakefile", "test/integration/app/README", "test/integration/app/script/about", "test/integration/app/script/console", "test/integration/app/script/destroy", "test/integration/app/script/generate", "test/integration/app/script/performance/benchmarker", "test/integration/app/script/performance/profiler", "test/integration/app/script/performance/request", "test/integration/app/script/plugin", "test/integration/app/script/process/inspector", "test/integration/app/script/process/reaper", "test/integration/app/script/process/spawner", "test/integration/app/script/runner", "test/integration/app/script/server", "test/integration/app/test/fixtures/items.yml", "test/integration/app/test/functional/eval_controller_test.rb", "test/integration/app/test/functional/items_controller_test.rb", "test/integration/app/test/test_helper.rb", "test/integration/app/test/unit/item_test.rb", "test/integration/server_test.rb", "test/setup.rb", "test/teardown.rb", "test/test_helper.rb", "test/unit/memcached_test.rb", "TODO", "interlock.gemspec"]
+  s.files = ["CHANGELOG", "examples/memcached.yml", "init.rb", "lib/interlock/action_controller.rb", "lib/interlock/action_view.rb", "lib/interlock/active_record.rb", "lib/interlock/config.rb", "lib/interlock/core_extensions.rb", "lib/interlock/interlock.rb", "lib/interlock/memcached.rb", "lib/interlock.rb", "LICENSE", "Manifest", "README", "tasks/interlock.rake", "test/integration/app/app/controllers/application.rb", "test/integration/app/app/controllers/eval_controller.rb", "test/integration/app/app/controllers/items_controller.rb", "test/integration/app/app/helpers/application_helper.rb", "test/integration/app/app/helpers/eval_helper.rb", "test/integration/app/app/helpers/items_helper.rb", "test/integration/app/app/models/item.rb", "test/integration/app/app/views/items/detail.rhtml", "test/integration/app/app/views/items/list.rhtml", "test/integration/app/app/views/items/recent.rhtml", "test/integration/app/app/views/items/show.rhtml", "test/integration/app/app/views/layouts/application.html.erb", "test/integration/app/app/views/shared/_related.rhtml", "test/integration/app/config/boot.rb", "test/integration/app/config/database.yml", "test/integration/app/config/environment.rb", "test/integration/app/config/environments/development.rb", "test/integration/app/config/environments/production.rb", "test/integration/app/config/environments/test.rb", "test/integration/app/config/initializers/inflections.rb", "test/integration/app/config/initializers/mime_types.rb", "test/integration/app/config/memcached.yml", "test/integration/app/config/routes.rb", "test/integration/app/db/migrate/001_create_items.rb", "test/integration/app/doc/README_FOR_APP", "test/integration/app/public/404.html", "test/integration/app/public/422.html", "test/integration/app/public/500.html", "test/integration/app/public/dispatch.cgi", "test/integration/app/public/dispatch.fcgi", "test/integration/app/public/dispatch.rb", "test/integration/app/public/favicon.ico", "test/integration/app/public/images/rails.png", "test/integration/app/public/index.html", "test/integration/app/public/javascripts/application.js", "test/integration/app/public/javascripts/controls.js", "test/integration/app/public/javascripts/dragdrop.js", "test/integration/app/public/javascripts/effects.js", "test/integration/app/public/javascripts/prototype.js", "test/integration/app/public/robots.txt", "test/integration/app/Rakefile", "test/integration/app/README", "test/integration/app/script/about", "test/integration/app/script/console", "test/integration/app/script/destroy", "test/integration/app/script/generate", "test/integration/app/script/performance/benchmarker", "test/integration/app/script/performance/profiler", "test/integration/app/script/performance/request", "test/integration/app/script/plugin", "test/integration/app/script/process/inspector", "test/integration/app/script/process/reaper", "test/integration/app/script/process/spawner", "test/integration/app/script/runner", "test/integration/app/script/server", "test/integration/app/test/fixtures/items.yml", "test/integration/app/test/functional/eval_controller_test.rb", "test/integration/app/test/functional/items_controller_test.rb", "test/integration/app/test/test_helper.rb", "test/integration/app/test/unit/item_test.rb", "test/integration/server_test.rb", "test/setup.rb", "test/teardown.rb", "test/test_helper.rb", "test/unit/interlock_test.rb", "test/unit/memcached_test.rb", "TODO", "interlock.gemspec"]
   s.has_rdoc = true
   s.homepage = %q{http://blog.evanweaver.com/files/doc/fauna/interlock/}
   s.require_paths = ["lib"]
   s.rubyforge_project = %q{fauna}
-  s.rubygems_version = %q{0.9.5}
-  s.summary = %q{An optimal-efficiency caching plugin for Rails.}
-  s.test_files = ["test/integration/server_test.rb", "test/unit/memcached_test.rb"]
+  s.rubygems_version = %q{1.0.1}
+  s.summary = %q{A Rails plugin for maintainable and high-efficiency caching.}
+  s.test_files = ["test/integration/server_test.rb", "test/unit/interlock_test.rb", "test/unit/memcached_test.rb"]
 
   s.add_dependency(%q<memcache_client>, [">= 1.5.0"])
 end
@@ -33,12 +33,14 @@ end
 # 
 # Echoe.new("interlock") do |p|
 #   p.project = "fauna"
-#   p.summary = "An optimal-efficiency caching plugin for Rails."
+#   p.summary = "A Rails plugin for maintainable and high-efficiency caching."
 #   p.url = "http://blog.evanweaver.com/files/doc/fauna/interlock/"  
 #   p.docs_host = "blog.evanweaver.com:~/www/bax/public/files/doc/"  
 #   p.dependencies = "memcache_client >=1.5.0"
 #   p.test_pattern = ["test/integration/*.rb", "test/unit/*.rb"]
 #   p.rdoc_pattern = ["README", "CHANGELOG", "TODO", "LICENSE", "lib/interlock/memcached.rb", "lib/interlock/interlock.rb", "lib/interlock/action_controller.rb", "lib/interlock/active_record.rb", "lib/interlock/action_view.rb", "lib/interlock/config.rb"]
+#   p.clean_pattern += ['test/integration/app/coverage', 'test/integration/app/db/schema.rb',
+#                       'test/integration/app/vendor/plugins/interlock']
 # end
 # 
 # desc "Run all the tests in production and development mode both"
@@ -50,3 +52,8 @@ end
 #   STDERR.puts "#{'='*80}\nProduction mode\n#{'='*80}"
 #   system("rake test:multi_rails:all")
 # end
+# 
+# task "tail" do
+#   log = "test/integration/app/log/development.log"
+#   system("touch #{log} && tail -f #{log} | grep interlock")
+# end

data/lib/interlock/action_controller.rb

@@ -2,20 +2,15 @@
 module ActionController #:nodoc:
   class Base
   
-    #
-    # Build the fragment key from a particular context. This must be deterministic 
-    # and stateful except for the tag. We can't scope the key to arbitrary params 
-    # because the view doesn't have access to which are relevant and which are 
-    # not.
-    #
-    # Note that the tag can be pretty much any object. Define #to_interlock_tag
-    # if you need custom tagging for some class. ActiveRecord::Base already
-    # has it defined appropriately.
-    #
-    # If you pass an Array of symbols as the tag, it will get value-mapped onto
-    # params and sorted. This makes granular scoping easier, although it doesn't
-    # sidestep the normal blanket invalidations.
-    #
+
+=begin rdoc
+Build the fragment key from a particular context. This must be deterministic and stateful except for the tag. We can't scope the key to arbitrary params because the view doesn't have access to which are relevant and which are not.
+
+Note that the tag can be pretty much any object. Define <tt>to_interlock_tag</tt> if you need custom tagging for some class. ActiveRecord::Base already has it defined appropriately.
+
+If you pass an Array of symbols as the tag, it will get value-mapped onto params and sorted. This makes granular scoping easier, although it doesn't sidestep the normal blanket invalidations.
+=end
+
     def caching_key(ignore = nil, tag = nil)
       ignore = Array(ignore)
       ignore = Interlock::SCOPE_KEYS if ignore.include? :all    
@@ -40,23 +35,107 @@ module ActionController #:nodoc:
       )
     end
     
-    #
-    # Mark a controller block for caching. Accepts a list of class dependencies for
-    # invalidation, as well as a :tag key for explicit fragment scoping.
-    #
+
+=begin rdoc    
+    
+<tt>behavior_cache</tt> marks a controller block for caching. It accepts a list of class dependencies for invalidation, as well as as <tt>:tag</tt> and <tt>:ignore</tt> keys for explicit fragment scoping. It does not accept a <tt>:ttl</tt> key.
+
+Please note that the behavior of nested <tt>behavior_cache</tt> blocks is undefined.
+
+== Declaring dependencies
+
+You can declare non-default invalidation dependencies by passing models to <tt>behavior_cache</tt> (you can also pass them to <tt>view_cache</tt>, but you should only do that if you are caching a fragment without an associated behavior block in the controller).
+
+<b>No dependencies (cache never invalidates):</b>
+  behavior_cache nil do
+  end
+  
+<b>Invalidate on any Media change:</b>
+  behavior_cache Media do
+  end
+  
+<b>Invalidate on any Media or Item change:</b>
+  behavior_cache Media, Item do
+  end
+  
+<b>Invalidate on Item changes if the Item <tt>id</tt> matches the current <tt>params[:id]</tt> value:</b>
+  behavior_cache Item => :id do
+  end
+
+You do not have to pass the same dependencies to <tt>behavior_cache</tt> and <tt>view_cache</tt> even for the same action. The set union of both dependency lists will be used.
+
+== Narrowing scope and caching multiple blocks
+
+Sometimes you need to cache multiple blocks in a controller, or otherwise get a more fine-grained scope. Interlock provides the <tt>:tag</tt> key for this purpose. <tt>:tag</tt> accepts either an array of symbols, which are mapped to <tt>params</tt> values, or an arbitrary object, which is converted to a string identifier. <b>Your corresponding behavior caches and view caches must have identical <tt>:tag</tt> values for the interlocking to take effect.</b>
+
+Note that <tt>:tag</tt> can be used to scope caches. You can simultaneously cache different versions of the same block, differentiating based on params or other logic. This is great for caching per-user, for example:
+
+  def profile
+    @user = current_user
+    behavior_cache :tag => @user do
+      @items = @user.items
+    end
+  end
+
+In the view, use the same <tt>:tag</tt> value (<tt>@user</tt>). Note that <tt>@user</tt> must be set outside of the behavior block in the controller, because its contents are used to decide whether to run the block in the first place.
+
+This way each user will see only their own cache. Pretty neat.
+
+== Broadening scope
+
+Sometimes the default scope (<tt>controller</tt>, <tt>action</tt>, <tt>params[:id]</tt>) is too narrow. For example, you might share a partial across actions, and set up its data via a filter. By default, Interlock will cache a separate version of it for each action. To avoid this, you can use the <tt>:ignore</tt> key, which lets you list parts of the default scope to ignore:
+
+  before_filter :recent
+  
+  private
+  
+  def recent
+    behavior_cache :ignore => :action do
+      @recent = Item.find(:all, :limit => 5, :order => 'updated_at DESC')
+    end
+  end
+
+Valid values for <tt>:ignore</tt> are <tt>:controller</tt>, <tt>:action</tt>, <tt>:id</tt>, and <tt>:all</tt>. You can pass an array of multiple values. <b>Just like with <tt>:tag</tt>, your corresponding behavior caches and view caches must have identical <tt>:ignore</tt> values.</b> Note that cache blocks with <tt>:ignore</tt> values still obey the regular invalidation rules.
+
+A good way to get started is to just use the default scope. Then <tt>grep</tt> in the production log for <tt>interlock</tt> and see what keys are being set and read. If you see lots of different keys go by for data that you know is the same, then set some <tt>:ignore</tt> values. 
+
+== Skipping caching
+
+You can pass <tt>:perform => false</tt> to disable caching, for example, in a preview action. Note that <tt>:perform</tt> only responds to <tt>false</tt>, not <tt>nil</tt>. This allows for handier view reuse because you can set <tt>:perform</tt> to an instance variable and it will still cache if the instance variable is not set:
+
+  def preview
+    @perform = false
+    behavior_cache :perform => @perform do
+    end
+    render :action => 'show'
+  end
+  
+And in the <tt>show.html.erb</tt> view:
+
+  <% view_cache :perform => @perform do %>
+  <% end %>
+
+=end    
+    
     def behavior_cache(*args)  
       conventional_class = begin; controller_name.classify.constantize; rescue NameError; end
       options, dependencies = Interlock.extract_options_and_dependencies(args, conventional_class)
       
       raise UsageError, ":ttl has no effect in a behavior_cache block" if options[:ttl]
-      
+
       key = caching_key(options.value_for_indifferent_key(:ignore), options.value_for_indifferent_key(:tag))      
-      Interlock.register_dependencies(dependencies, key)
-          
-      # See if the fragment exists, and run the block if it doesn't.
-      unless read_fragment(key)    
-        Interlock.say key, "is running the controller block"
+
+      if options[:perform] == false
+        Interlock.say key, "is not cached"
         yield
+      else
+        Interlock.register_dependencies(dependencies, key)
+            
+        # See if the fragment exists, and run the block if it doesn't.
+        unless read_fragment(key, :assign_content_for => false)
+          Interlock.say key, "is running the controller block"
+          yield
+        end
       end
     end
     
@@ -70,7 +149,7 @@ module ActionController #:nodoc:
     # Callback to reset the local cache.
     #
     def clear_interlock_local_cache
-      Interlock.local_cache = ActionController::Base::MemoryStore.new
+      Interlock.local_cache = ::ActionController::Base::MemoryStore.new
       RAILS_DEFAULT_LOGGER.warn "** cleared interlock local cache"
     end    
     
@@ -83,39 +162,59 @@ module ActionController #:nodoc:
     module Fragments
        
       #
-      # Replaces Rail's write_fragment method. Avoids extra checks for regex keys, 
-      # which are unsupported, adds more detailed logging information, and stores 
-      # writes in the local process cache too to avoid duplicate memcached requests.
+      # Replaces Rail's write_fragment method. Avoids extra checks for regex keys 
+      # which are unsupported, adds more detailed logging information, stores writes 
+      # in the local process cache too to avoid duplicate memcached requests, and
+      # includes the content_for cache in the fragment.
       #
-      def write_fragment(key, content, options = nil)
+      def write_fragment(key, block_content, options = nil)
         return unless perform_caching
+        
+        content = [block_content, @template.cached_content_for]
 
         fragment_cache_store.write(key, content, options)
         Interlock.local_cache.write(key, content, options)
 
         Interlock.say key, "wrote"
 
-        content
+        block_content
       end
 
       #
       # Replaces Rail's read_fragment method. Avoids checks for regex keys, 
-      # which are unsupported, adds more detailed logging information, and
-      # checks the local process cache before hitting memcached. Hits on 
-      # memcached are then stored back locally to avoid duplicate requests.
+      # which are unsupported, adds more detailed logging information, checks 
+      # the local process cache before hitting memcached, and restores the
+      # content_for cache. Hits on memcached are also stored back locally to 
+      # avoid duplicate requests.
       #
       def read_fragment(key, options = nil)
         return unless perform_caching
 
         if content = Interlock.local_cache.read(key, options)
           # Interlock.say key, "read from local cache"
-        elsif content = fragment_cache_store.read(key, options)            
+        elsif content = fragment_cache_store.read(key, options)                    
+          raise FragmentConsistencyError, "#{key} is not an Array" unless content.is_a? Array
           Interlock.say key, "read from memcached"
           Interlock.local_cache.write(key, content, options)
         else
-          # Interlock.say key, "not found"
+          # Not found
+          return nil 
         end
-        content
+        
+        raise FragmentConsistencyError, "#{key}::content is not a String" unless content.first.is_a? String
+
+        options ||= {}
+        # Note that 'nil' is considered true for :assign_content_for
+        if options[:assign_content_for] != false and content.last 
+          # Extract content_for variables
+          content.last.each do |name, value| 
+            raise FragmentConsistencyError, "#{key}::content_for(:#{name}) is not a String" unless value.is_a? String
+            # We'll just call the helper because that will handle nested view_caches properly.
+            @template.send(:content_for, name, value)
+          end
+        end
+
+        content.first        
       end      
       
     end

data/lib/interlock/action_view.rb

@@ -1,28 +1,75 @@
 
 module ActionView #:nodoc:
+  class Base #:nodoc:
+    attr_accessor :cached_content_for
+  end
+
   module Helpers #:nodoc:
     module CacheHelper 
      
-     #
-     # Mark a corresponding view block for caching. Accepts a :tag key for 
-     # explicit scoping. You can specify dependencies here if you really want
-     # to, for example, if you don't have any controller block at all.
-     #
-     
-     def view_cache(*args, &block)
-       conventional_class = begin; controller.controller_name.classify.constantize; rescue NameError; end
-       options, dependencies = Interlock.extract_options_and_dependencies(args, conventional_class)  
-       
+=begin rdoc     
+
+<tt>view_cache</tt> marks a corresponding view block for caching. It accepts <tt>:tag</tt> and <tt>:ignore</tt> keys for explicit scoping, as well as a <tt>:ttl</tt> key and a <tt>:perform</tt> key. 
+
+You can specify dependencies in <tt>view_cache</tt> if you really want to. Note that unlike <tt>behavior_cache</tt>, <tt>view_cache</tt> doesn't set up any default dependencies.
+
+Nested <tt>view_cache</tt> blocks work fine. You would only need to nest if you had a slowly invalidating block contained in a more quickly invalidating block; otherwise there's no benefit.
+
+Finally, caching <tt>content_for</tt> within a <tt>view_cache</tt> works, unlike regular Rails. It even works in nested caches.
+
+== Setting a TTL
+
+Use the <tt>:ttl</tt> key to specify a maximum time-to-live, in seconds:
+
+  <% view_cache :ttl => 5.minutes do %>
+  <% end %>
+
+Note that the cached item is not guaranteed to live this long. An invalidation rule could trigger first, or memcached could eject the item early due to the LRU.
+
+== View caching without action caching
+
+It's fine to use a <tt>view_cache</tt> block without a <tt>behavior_cache</tt> block. For example, to mimic regular fragment cache behavior, but take advantage of memcached's <tt>:ttl</tt> support, call:
+
+  <% view_cache :ignore => :all, :tag => 'sidebar', :ttl => 5.minutes %>
+  <% end %>  
+  
+== Dependencies, scoping, and other options
+
+See ActionController::Base for explanations of the rest of the options. The <tt>view_cache</tt> and <tt>behavior_cache</tt> APIs are identical except for setting the <tt>:ttl</tt>, which can only be done in the view, and the default dependency, which is only set by <tt>behavior_cache</tt>.
+
+=end     
+     def view_cache(*args, &block)       
+       # conventional_class = begin; controller.controller_name.classify.constantize; rescue NameError; end
+       options, dependencies = Interlock.extract_options_and_dependencies(args, nil)  
+
        key = controller.caching_key(options.value_for_indifferent_key(:ignore), options.value_for_indifferent_key(:tag))      
-       Interlock.register_dependencies(dependencies, key)
        
-       # Interlock.say key "is rendering"
-   
-       @controller.cache_erb_fragment(
-         block, 
-         key, 
-         :ttl => (options.value_for_indifferent_key(:ttl) or Interlock.config[:ttl])
-       )
+       if options[:perform] == false
+         # Interlock.say key, "is not cached"
+         block.call
+       else       
+         Interlock.register_dependencies(dependencies, key)
+
+         # Interlock.say key, "is rendering"
+
+         @cached_content_for, previous_cached_content_for = {}, @cached_content_for
+         @controller.cache_erb_fragment(
+           block, 
+           key, 
+           :ttl => (options.value_for_indifferent_key(:ttl) or Interlock.config[:ttl])
+         )
+         
+         # This is tricky. If we were already caching content_fors in a parent block, we need to 
+         # append the content_fors set in the inner block to those already set in the outer block. 
+         if previous_cached_content_for
+           @cached_content_for.each do |key, value|
+             previous_cached_content_for[key] = "#{previous_cached_content_for[key]}#{value}"
+           end
+         end
+         
+         # Restore the cache state
+         @cached_content_for = previous_cached_content_for         
+       end
      end
      
     #:stopdoc:
@@ -30,5 +77,25 @@ module ActionView #:nodoc:
     #:startdoc:
      
     end
+
+  
+    module CaptureHelper
+      #
+      # Override content_for so we can cache the instance variables it sets along with the fragment.
+      #
+      def content_for(name, content = nil, &block)
+        ivar = "@content_for_#{name}"
+        existing_content = instance_variable_get(ivar).to_s
+        this_content = (block_given? ? capture(&block) : content)
+        
+        # If we are in a view_cache block, cache what we added to this instance variable
+        if @cached_content_for
+          @cached_content_for[name] = "#{@cached_content_for[name]}#{this_content}"
+        end
+        
+        instance_variable_set(ivar, existing_content + this_content)
+      end    
+    end
+
   end
 end

data/lib/interlock/active_record.rb

@@ -14,7 +14,7 @@ module ActiveRecord #:nodoc:
     #
     
     def expire_interlock_keys
-      (CACHE.get(Interlock.dependency_key(self.class)) || {}).each do |key, scope|
+      (CACHE.get(Interlock.dependency_key(self.class.base_class)) || {}).each do |key, scope|
         if scope == :all or (scope == :id and key.field(4) == self.to_param.to_s)
           Interlock.say key, "invalidated by rule #{self.class} -> #{scope.inspect}."
           Interlock.invalidate key