cells 3.5.0 → 3.5.1

data/CHANGES.textile

@@ -1,3 +1,11 @@
+h2. 3.5.1
+  * No longer pass an explicit Proc but a versioner block to @Cell.Base.cache@. Example: @cache :show do "v1" end@
+  * Caching.cache_key_for now uses @ActiveSupport::Cache.expand_cache_key@. Consequently, a key which used to be like @"cells/director/count/a=1/b=2"@ now is @cells/director/count/a=1&b=2@ and so on. Be warned that this might break your home-made cache expiry.
+  * Controller#expire_cell_state now expects the cell class as first arg. Example: @expire_cell_state(DirectorCell, :count)@
+  
+h3. Bugfixes
+  * Passing options to @render :state@ in views finally works: @render({:state => :list_item}, item, i)@
+
 h2. 3.5.0
 
 h3. Changes

data/cells.gemspec

@@ -12,14 +12,14 @@ Gem::Specification.new do |s|
   s.email       = ["apotonick@gmail.com"]
   s.homepage    = "http://cells.rubyforge.org"
   s.summary     = %q{View Components for Rails.}
-  s.description = %q{Cells are View Components for Rails. They are lightweight controllers, can be rendered in views and thus provide an elegant and fast way for encapsulation and component-orientation.}
+  s.description = %q{Cells are view components for Rails. They are lightweight controllers, can be rendered in views and thus provide an elegant and fast way for encapsulation and component-orientation.}
   
   s.files         = `git ls-files`.split("\n")
   s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
   
-  s.add_dependency "rails",   "~> 3.0"
+  s.add_dependency "rails",   "~> 3.0.0"
   
   s.add_development_dependency "shoulda"
   s.add_development_dependency "haml"

data/lib/cell/caching.rb

@@ -6,59 +6,42 @@ module Cell
     extend ActiveSupport::Concern
 
     module ClassMethods
-      # Activate caching for the state <tt>state</tt>. If no other options are passed
-      # the view will be cached forever.
+      # Caches the rendered view of +state+.
       #
-      # You may pass a Proc or a Symbol as cache expiration <tt>version_proc</tt>.
-      # This method is called every time the state is rendered, and is expected to return a
-      # Hash containing the cache key ingredients.
+      # Examples:
       #
-      # Additional options will be passed directly to the cache store when caching the state.
-      # Useful for simply setting a TTL for a cached state.
-      # Note that you may omit the <tt>version_proc</tt>.
+      # This will cache forever.
       #
+      #   class CartCell < Cell::Base
+      #     cache :show
       #
-      # Example:
-      #   class CachingCell < ::Cell::Base
-      #     cache :versioned_cached_state, Proc.new{ {:version => 0} }
-      # would result in the complete cache key
-      #   cells/CachingCell/versioned_cached_state/version=0
+      # You can also pass options to the caching engine as known from Rails caching.
       #
-      # If you provide a symbol, you can access the cell instance directly in the versioning
-      # method:
+      #   cache :show, :expires_in => 10.minutes
       #
-      #   class CachingCell < ::Cell::Base
-      #     cache :cached_state, :my_cache_version
+      # If you need your own granular cache keys, pass a versioner block.
       #
-      #     def my_cache_version
-      #       { :user     => current_user.id,
-      #         :item_id  => params[:item] }
-      #       }
-      #     end
-      # results in a very specific cache key, for customized caching:
-      #   cells/CachingCell/cached_state/user=18/item_id=1
+      #   cache :show do |cell|
+      #     "user/#{cell.options[:id]}"
+      #   end
       #
-      # You may also set a TTL only, e.g. when using the memcached store:
+      # This will result in a cache key like <tt>cells/cart/show/user/1</tt>.
       #
-      #  cache :cached_state, :expires_in => 3.minutes
+      # Alternatively, use an instance method.
       #
-      # Or use both, having a versioning proc <em>and</em> a TTL expiring the state as a fallback
-      # after a certain amount of time.
+      #   cache :show, :versioner
+      #   def versioner
+      #     "user/#{options[:id]}"
+      #   end
       #
-      #  cache :cached_state, Proc.new { {:version => 0} }, :expires_in => 10.minutes
-      #--
-      ### TODO: implement for string, nil.
-      ### DISCUSS: introduce return method #sweep ? so the Proc can explicitly
-      ###   delegate re-rendering to the outside.
-      #--
-      def cache(state, version_proc=nil, cache_opts={})
-        if version_proc.is_a?(Hash)
-          cache_opts    = version_proc
-          version_proc  = nil
-        end
-
-        version_procs[state]  = version_proc
-        cache_options[state]  = cache_opts
+      # Two things to mention here.
+      # * The return value of the method/block is <em>appended</em> to the state cache key.
+      # * You may return a string, a hash, an array, ActiveSupport::Caching will compile it. 
+      def cache(state, *args, &block)
+        options = args.extract_options!
+        
+        version_procs[state]  = args.first || block
+        cache_options[state]  = options
       end
 
       def version_procs
@@ -69,55 +52,55 @@ module Cell
         @cache_options ||= {}
       end
 
-      def cache_store #:nodoc:
+      def cache_store
+        # DISCUSS: move to instance level and delegate to #config/#parent_controller.
+        # This would allow convenient cache settings per cell (if needed).
         ::ActionController::Base.cache_store
       end
-
-      def cache_key_for(cell_class, state, args = {}) #:nodoc:
-        key_pieces = [cell_class, state]
-
-        args.collect{|a,b| [a.to_s, b]}.sort.each{ |k,v| key_pieces << "#{k}=#{v}" }
-        key = key_pieces.join('/')
-
-        ::ActiveSupport::Cache.expand_cache_key(key, :cells)
+      
+      # Computes the complete, namespaced cache key for +state+.
+      def state_cache_key(state, key_parts={})
+        expand_cache_key([cell_name, state, key_parts])
       end
 
-      def expire_cache_key(key, opts=nil)
-        cache_store.delete(key, opts)
+      def expire_cache_key(key, *args)
+        cache_store.delete(key, *args)
       end
-
-      def cache_configured?
-        ::ActionController::Base.cache_configured?
+      
+      def cache?(state)
+        # DISCUSS: why is it private?
+        ActionController::Base.send(:cache_configured?) and state_cached?(state)
+      end
+      
+    protected
+      # Compiles cache key and adds :cells namespace to +key+, according to the
+      # ActiveSupport::Cache.expand_cache_key API.
+      def expand_cache_key(key)
+        ::ActiveSupport::Cache.expand_cache_key(key, :cells)
+      end
+      
+      def state_cached?(state)
+        version_procs.has_key?(state)
       end
     end
 
     def render_state(state, *args)
-      return super(state, *args) unless state_cached?(state)
-
-      key     = cache_key(state, call_version_proc_for_state(state))
+      return super(state, *args) unless self.class.cache?(state)
+      
+      key     = self.class.state_cache_key(state, call_state_versioner(state))
       options = self.class.cache_options[state]
-
+      
       self.class.cache_store.fetch(key, options) do
         super(state, *args)
       end
     end
-
-    # Call the versioning Proc for the respective state.
-    def call_version_proc_for_state(state)
-      version_proc = self.class.version_procs[state]
-
-      return {} unless version_proc # call to #cache was without any args.
-
+    
+    def call_state_versioner(state)
+      version_proc = self.class.version_procs[state] or return
+      
       return version_proc.call(self) if version_proc.kind_of?(Proc)
       send(version_proc)
     end
-
-    def cache_key(state, args = {}) #:nodoc:
-      self.class.cache_key_for(self.class.cell_name, state, args)
-    end
-
-    def state_cached?(state)
-      self.class.version_procs.has_key?(state)
-    end
+    
   end
 end

data/lib/cell/rails.rb

@@ -10,11 +10,10 @@ module Cell
 
 
     class View < ActionView::Base
-      def render(options = {}, locals = {}, &block)
-        if options[:state] or options[:view]
-          return @_controller.render(options, &block)
-        end
-
+      def render(*args, &block)
+        options = args.first.is_a?(::Hash) ? args.first : {}  # this is copied from #render by intention.
+        
+        return controller.render(*args, &block) if options[:state] or options[:view]
         super
       end
     end

data/lib/cells/rails.rb

@@ -36,9 +36,14 @@ module Cells
       #   end
       #
       # will expire the view for state <tt>:display_list</tt> in the cell <tt>MyListingCell</tt>.
-      def expire_cell_state(cell_name, state, args={}, opts=nil)
-        key = ::Cell::Base.cache_key_for(cell_name, state, args)
-        ::Cell::Base.expire_cache_key(key, opts)
+      def expire_cell_state(cell_class, state, args={}, opts=nil)
+        if cell_class.is_a?(Symbol)
+          ActiveSupport::Deprecation.warn "Please pass the cell class into #expire_cell_state, as in expire_cell_state(DirectorCell, :count, :user_id => 1)"
+          cell_class = Cell::Base.class_from_cell_name(cell_class)
+        end
+        
+        key = cell_class.state_cache_key(state, args)
+        cell_class.expire_cache_key(key, opts)
       end
     end
 

data/lib/cells/version.rb

@@ -1,3 +1,3 @@
 module Cells
-  VERSION = '3.5.0'
+  VERSION = '3.5.1'
 end

data/test/rails/caching_test.rb

@@ -1,203 +1,272 @@
 require 'test_helper'
 
 class DirectorCell < Cell::Rails
-  cache :count
+  attr_reader :count
   
-  @@counter = 0
-  cattr_accessor :counter
+  def initialize(*)
+    super
+    @count = 0
+  end
   
-  def self.increment!
-    @@counter += 1
+  cache :tock
+  def tock
+    @count += 1
+    render :text => @count
   end
+end
+
+class CachingUnitTest < ActiveSupport::TestCase
+  include Cell::TestCase::TestMethods
   
-  def self.reset!
-    @@counter = 0
+  setup do
+    ActionController::Base.cache_store.clear
+    ActionController::Base.perform_caching = true
+    @cell   = cell(:director)
+    @class  = @cell.class
   end
   
-  def increment!
-    self.class.increment!
+  
+  context ".state_cache_key" do
+    should "accept state only" do
+      assert_equal "cells/director/count/", @class.state_cache_key(:count)
+    end
+    
+    should "accept hash as key parts" do
+      assert_equal "cells/director/count/a=1&b=2", @class.state_cache_key(:count, :b=>2, :a=>1)
+    end
+    
+    should "accept array as key parts" do
+      assert_equal "cells/director/count/1/2/3", @class.state_cache_key(:count, [1,2,3])
+    end
+    
+    should "accept string as key parts" do
+      assert_equal "cells/director/count/1/2", @class.state_cache_key(:count, "1/2")
+    end
+    
+    should "accept nil as key parts" do
+      assert_equal "cells/director/count/", @class.state_cache_key(:count, nil)
+    end
   end
   
-  def count
-    render :text => increment!
-  end 
-end
-
-class CachingTest < ActiveSupport::TestCase
-  include Cell::TestCase::TestMethods
   
-  context "The DirectorCell" do
-    setup do
-      DirectorCell.reset!
+  context ".expand_cache_key" do
+    should "add :cells namespace" do
+      assert_equal "cells/director/count", @class.send(:expand_cache_key, [:director, :count])
+    end
+  end
+  
+  
+  context ".state_cached?" do
+    should "return true for cached" do
+      assert @class.send :state_cached?, :count
     end
     
-    should "respond to #increment" do
-      assert_equal 0, DirectorCell.counter
-      assert_equal 1, DirectorCell.increment!
-      assert_equal 1, DirectorCell.counter
+    should "return false otherwise" do
+      assert_not @class.send :state_cached?, :sing
     end
   end
   
-  context "A cell" do
-    setup do
-      ::ActionController::Base.cache_store = :memory_store
-      ::ActionController::Base.perform_caching = true
-      DirectorCell.reset!
+  
+  context ".cache?" do
+    should "return true for cached" do
+      assert @cell.class.cache?(:count)
     end
     
-    should "respond to state_cached?" do
-      assert cell(:director).state_cached?(:count)
-      assert_not cell(:director).state_cached?(:sing)
+    should "return false otherwise" do
+      assert_not @cell.class.cache?(:sing)
     end
     
-    context "caching a state" do
-      setup do
-        @proc = Proc.new{}
+    context "perform_caching turned off" do
+      teardown do
+        ::ActionController::Base.perform_caching = true
       end
       
-      should "save the version proc" do
-        DirectorCell.cache :count, @proc
-        
-        assert_equal @proc, cell(:director).class.version_procs[:count]
-        assert_equal({}, cell(:director).class.cache_options[:count])
+      should "always return false if caching turned-off" do
+        ::ActionController::Base.perform_caching = false
+        assert_not @cell.class.cache?(:count)
+        assert_not @cell.class.cache?(:sing)
       end
-      
-      should "save the cache options" do
-        DirectorCell.cache :count, @proc, :expires_in => 10.minutes
-
-        assert_equal @proc, cell(:director).class.version_procs[:count]
-        assert_equal({:expires_in => 10.minutes}, cell(:director).class.cache_options[:count])
+    end
+  end
+  
+  
+  context ".expire_cache_key" do
+    setup do
+      @key = @class.state_cache_key(:tock)
+      assert_equal "1", render_cell(:director, :tock)
+      assert_equal "1", @class.cache_store.read(@key)
+    end
+    
+    should "delete the state from cache" do
+      @class.expire_cache_key(@key)
+      assert_not @class.cache_store.read(@key)
+    end
+    
+    should "be available in controllers for sweepers" do
+      MusicianController.new.expire_cell_state(DirectorCell, :tock)
+      assert_not @class.cache_store.read(@key)
+    end
+    
+    should "accept cache options" do
+      key = @class.state_cache_key(:tock, :volume => 9)
+      assert Cell::Base.cache_store.write(key, 'ONE!')
+   
+      MusicianController.new.expire_cell_state(DirectorCell, :tock, :volume => 9)
+      assert_equal "1", @class.cache_store.read(@key)
+      assert_not ::Cell::Base.cache_store.read(key)
+    end
+    
+    should "raise a deprecation notice when passing in a :symbol" do
+      assert_deprecated do
+        MusicianController.new.expire_cell_state(:director, :tock)
       end
+      assert_not @class.cache_store.read(@key)
+    end
+  end
+  
+  
+  context ".cache" do
+    setup do
+      @proc = Proc.new{}
+    end
+    
+    should "accept a state name, only" do
+      @class.cache :count
       
-      should "not mix caching configuration with other classes" do
-        DirectorCell.cache :count
-        class SecondDirectorCell < DirectorCell; end
-        SecondDirectorCell.cache :count, @proc
-        
-        assert_equal nil, cell(:director).class.version_procs[:count]
-        assert_equal @proc, cell(:"caching_test/second_director").class.version_procs[:count]
-      end
+      assert_not @class.version_procs[:count]
+      assert_equal({}, @class.cache_options[:count])
     end
     
-    context "caching without options" do
-      setup do
-        key = cell(:director).cache_key(:count, :count => 0)
-        Cell::Base.expire_cache_key(key)  ### TODO: separate test
-      end
+    should "accept state and cache options" do
+      @class.cache :count, :expires_in => 10.minutes
       
-      should "cache forever" do
-        DirectorCell.class_eval do
-          cache :count
-        end
-        
-        assert cell(:director).state_cached?(:count)
-        assert_equal nil, cell(:director).class.version_procs[:count]
-        assert_equal({}, cell(:director).class.cache_options[:count])
-        
-        assert_equal render_cell(:director, :count), render_cell(:director, :count)
-      end
+      assert_not @class.version_procs[:count]
+      assert_equal({:expires_in => 10.minutes}, @class.cache_options[:count])
+    end
+    
+    should "accept args and versioner block" do
+      @class.cache :count, :expires_in => 10.minutes do "v1" end
+
+      assert_kind_of Proc, @class.version_procs[:count]
+      assert_equal({:expires_in => 10.minutes}, @class.cache_options[:count])
+    end
+    
+    should "stil accept a versioner proc, only" do
+      @class.cache :count, @proc
       
-      should "not cache at all" do
-        DirectorCell.class_eval do
-          def dictate
-            render :text => increment!
-          end
-        end
-        
-        assert_equal "1", render_cell(:director, :dictate)
-        assert_equal "2", render_cell(:director, :dictate)
-      end
+      assert_equal @proc, @class.version_procs[:count]
+      assert_equal({},    @class.cache_options[:count])
+    end
+    
+    should "stil accept a versioner block" do
+      @class.cache :count do "v1" end
       
-      should "expire the cache with a version proc" do
-        DirectorCell.class_eval do
-          cache :count, Proc.new { |cell|
-            cell.class.counter >= 2 ? {:count => 2} : {:count => 0}
-          }
-          
-          def count
-            render :text => increment!
-          end 
-        end
-        DirectorCell.reset!
-        
-        assert_equal "1", render_cell(:director, :count)
-        assert_equal "1", render_cell(:director, :count)  # cached.
-        
-        DirectorCell.counter = 2  # invalidates the view cache.
-        assert_equal "3", render_cell(:director, :count)
-        assert_equal "3", render_cell(:director, :count)  # cached.
-      end
+      assert_kind_of Proc, @class.version_procs[:count]
+      assert_equal({},    @class.cache_options[:count])
+    end
+    
+    should "not inherit caching configuration" do
+      @class.cache :count
+      klass = Class.new(@class)
+      klass.cache :count, @proc
       
-      should "expire the cache with an instance method" do
-        DirectorCell.class_eval do
-          cache :count, :expire_count
-          
-          def expire_count
-            self.class.counter >= 2 ? {:count => 2} : {:count => 0}
-          end
-          
-          def count
-            render :text => increment!
-          end 
-        end
-        DirectorCell.reset!
-        
-        assert_equal "1", render_cell(:director, :count)
-        assert_equal "1", render_cell(:director, :count)  # cached.
-        
-        DirectorCell.counter = 2  # invalidates the view cache.
-        assert_equal "3", render_cell(:director, :count)
-        assert_equal "3", render_cell(:director, :count)  # cached.
-      end
+      assert_not cell(:director).class.version_procs[:count]
+      assert_equal @proc, klass.version_procs[:count]
     end
   end
+end
 
-  context "cache_key" do
-    setup do
-      @cell = cell(:director)
-    end
+class CachingFunctionalTest < ActiveSupport::TestCase
+  include Cell::TestCase::TestMethods
+
+  setup do
+    ActionController::Base.cache_store.clear
+    ActionController::Base.perform_caching = true
+    setup # from Cell::TestCase::TestMethods
     
-    should "respond to cache_key" do
-      assert_equal "cells/director/count", @cell.cache_key(:count)
-      assert_equal @cell.cache_key(:count), ::Cell::Base.cache_key_for(:director, :count)
+    @cell   = cell(:director)
+    @class  = @cell.class
+  end
+  
+  context "turned off" do
+    should "not invoke caching" do
+      ::ActionController::Base.perform_caching = false
+      
+      assert_equal "1", @cell.render_state(:tock)
+      assert_equal "2", @cell.render_state(:tock)
     end
-    
-    should "order options lexically" do
-      assert_equal "cells/director/count/a=1/b=2", @cell.cache_key(:count, :b => 2, :a => 1)
+  end  
+  
+  
+  context "without options" do
+    should "cache forever" do
+      @class.cache :tock
+      assert_equal "1", render_cell(:director, :tock)
+      assert_equal "1", render_cell(:director, :tock)
     end
   end
   
-  context "expire_cache_key" do
-    setup do
-      DirectorCell.class_eval do
-        cache :count
-        def count
-          render :text => increment!
+  
+  context "uncached states" do
+    should "not cache at all" do
+      @class.class_eval do
+        def dictate
+          @count ||= 0
+          render :text => (@count += 1)
         end
       end
-      DirectorCell.reset!
       
-      @key = cell(:director).cache_key(:count)
-      render_cell(:director, :count)
-      assert_equal "1", ::Cell::Base.cache_store.read(@key)
+      assert_equal "1", @cell.render_state(:dictate)
+      assert_equal "2", @cell.render_state(:dictate)
+    end
+  end
+  
+  context "with versioner" do
+    setup do
+      @class.class_eval do
+        def count(i)
+          render :text => i
+        end
+      end
     end
     
-    should "delete the view from cache" do
-      ::Cell::Base.expire_cache_key(@key)
-      assert_not ::Cell::Base.cache_store.read(@key)
+    should "compute the key with the proc" do
+      @class.cache :count do |cell|
+        (cell.options % 2)==0 ? {:count => "even"} : {:count => "odd"}
+      end
+      # example cache key: cells/director/count/count=odd
+      
+      assert_equal "1", render_cell(:director, :count, 1)
+      assert_equal "2", render_cell(:director, :count, 2)
+      assert_equal "1", render_cell(:director, :count, 3)
+      assert_equal "2", render_cell(:director, :count, 4)
     end
     
-    should "be available in controllers for sweepers" do
-      MusicianController.new.expire_cell_state(:director, :count)
-      assert_not ::Cell::Base.cache_store.read(@key)
+    should "compute the key with an instance method" do
+      @class.cache :count, :version
+      @class.class_eval do
+        def version
+          (options % 3)==0 ? {:count => "even"} : {:count => "odd"}
+        end
+      end
+      
+      assert_equal "1", render_cell(:director, :count, 1)
+      assert_equal "1", render_cell(:director, :count, 2)
+      assert_equal "3", render_cell(:director, :count, 3)
+      assert_equal "1", render_cell(:director, :count, 4)
+      assert_equal "1", render_cell(:director, :count, 5)
+      assert_equal "3", render_cell(:director, :count, 6)
     end
     
-    should "accept cache options" do
-      key = cell(:director).cache_key(:count, :volume => 9)
-      assert ::Cell::Base.cache_store.write(key, 'ONE!')
-   
-      MusicianController.new.expire_cell_state(:director, :count, :volume => 9)
-      assert_not ::Cell::Base.cache_store.read(key)
+    should "allow returning strings, too" do
+      @class.cache :count do |cell|
+        (cell.options % 2)==0 ? "even" : "odd"
+      end
+      
+      assert_equal "1", render_cell(:director, :count, 1)
+      assert_equal "2", render_cell(:director, :count, 2)
+      assert_equal "1", render_cell(:director, :count, 3)
+      assert_equal "2", render_cell(:director, :count, 4)
     end
   end
 end

data/test/rails/view_test.rb

@@ -18,5 +18,21 @@ class RailsViewTest < ActiveSupport::TestCase
       end
     end
     
+    should "respond to render :state" do
+      assert_equal("Doo", in_view(:bassist) do
+        render :state => :play
+      end)
+    end
+    
+    should "respond to render :state with options" do
+      BassistCell.class_eval do
+        def listen(*args)
+          render :text => "Listening to #{args.join(' ')}"
+        end
+      end
+      assert_equal("Listening to Much the Same", in_view(:bassist) do
+        render({:state => :listen}, "Much", "the", "Same")
+      end)
+    end
   end
 end

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 3
   - 5
-  - 0
-  version: 3.5.0
+  - 1
+  version: 3.5.1
 platform: ruby
 authors: 
 - Nick Sutterer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-05 00:00:00 +01:00
+date: 2011-02-10 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -28,7 +28,8 @@ dependencies:
         segments: 
         - 3
         - 0
-        version: "3.0"
+        - 0
+        version: 3.0.0
   type: :runtime
   version_requirements: *id001
 - !ruby/object:Gem::Dependency 
@@ -57,7 +58,7 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id003
-description: Cells are View Components for Rails. They are lightweight controllers, can be rendered in views and thus provide an elegant and fast way for encapsulation and component-orientation.
+description: Cells are view components for Rails. They are lightweight controllers, can be rendered in views and thus provide an elegant and fast way for encapsulation and component-orientation.
 email: 
 - apotonick@gmail.com
 executables: []