cells 3.5.1 → 3.5.2

data/CHANGES.textile

@@ -1,4 +1,14 @@
+h2. 3.5.2
+  
+h3. Bugfixes
+  * Controller#render_cell now accepts multiple args as options.
+
+h3. Changes
+  * Caching versioners now can accept state-args or options from the #render_cell call. This way, you don't have to access #options at all anymore.
+
+
 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)@
@@ -6,6 +16,7 @@ h2. 3.5.1
 h3. Bugfixes
   * Passing options to @render :state@ in views finally works: @render({:state => :list_item}, item, i)@
 
+
 h2. 3.5.0
 
 h3. Changes

data/README.rdoc

@@ -124,13 +124,16 @@ Cells do strict view caching. No cluttered fragment caching. Add
 
 and your cart will be re-rendered after 10 minutes.
 
-There are multiple advanced options for expiring your view caches, including an expiration lambda.
+You can expand the state's cache key - why not use a versioner block to do just this?
 
   class ShoppingCartCell < Cell::Rails 
-    cache :display do |cell|
-      Item.still_valid?
+    cache :display do |cell, options|
+      options[:items].md5
     end
 
+The return value is appended to the state key: <tt>"cells/shopping_cart/display/0ecb1360644ce665a4ef"</tt>.
+
+API here[http://rdoc.info/gems/cells/Cell/Caching/ClassMethods#cache-instance_method].
 
 == Testing
 

data/lib/cell.rb

@@ -4,19 +4,19 @@ module Cell
   extend ActiveSupport::Concern
 
   module ClassMethods
-    def render_cell_for(controller, name, state, opts={})
-      cell = create_cell_for(controller, name, opts)  # DISCUSS: we always save options.
+    def render_cell_for(controller, name, state, *args)
+      cell = create_cell_for(controller, name, *args)  # DISCUSS: we always save options.
       yield cell if block_given?
       
-      return cell.render_state(state, opts) if cell.state_accepts_args?(state)
+      return cell.render_state(state, *args) if cell.state_accepts_args?(state)
       cell.render_state(state)  # backward-compat.
     end
     
     # Creates a cell instance. Note that this method calls builders which were attached to the
     # class with Cell::Base.build - this might lead to a different cell being returned.
-    def create_cell_for(controller, name, opts={})
-      build_class_for(controller, class_from_cell_name(name), opts).
-      new(controller, opts)
+    def create_cell_for(controller, name, *args)
+      build_class_for(controller, class_from_cell_name(name), *args).
+      new(controller, *args)
     end
     
     # Adds a builder to the cell class. Builders are used in #render_cell to find out the concrete
@@ -49,9 +49,9 @@ module Cell
       builders << block
     end
     
-    def build_class_for(controller, target_class, opts)
+    def build_class_for(controller, target_class, *args)
       target_class.builders.each do |blk|
-        res = controller.instance_exec(opts, &blk) and return res
+        res = controller.instance_exec(*args, &blk) and return res
       end
       target_class
     end
@@ -91,7 +91,7 @@ module Cell
     end
     
     def state_accepts_args?(state)
-      method(state).arity == 1
+      method(state).arity > 0
     end
   end
 end

data/lib/cell/caching.rb

@@ -21,7 +21,7 @@ module Cell
       #
       # If you need your own granular cache keys, pass a versioner block.
       #
-      #   cache :show do |cell|
+      #   cache :show do |cell, options|
       #     "user/#{cell.options[:id]}"
       #   end
       #
@@ -30,7 +30,7 @@ module Cell
       # Alternatively, use an instance method.
       #
       #   cache :show, :versioner
-      #   def versioner
+      #   def versioner(options)
       #     "user/#{options[:id]}"
       #   end
       #
@@ -87,7 +87,7 @@ module Cell
     def render_state(state, *args)
       return super(state, *args) unless self.class.cache?(state)
       
-      key     = self.class.state_cache_key(state, call_state_versioner(state))
+      key     = self.class.state_cache_key(state, call_state_versioner(state, *args))
       options = self.class.cache_options[state]
       
       self.class.cache_store.fetch(key, options) do
@@ -95,11 +95,12 @@ module Cell
       end
     end
     
-    def call_state_versioner(state)
+  protected
+    def call_state_versioner(state, *args)
       version_proc = self.class.version_procs[state] or return
       
-      return version_proc.call(self) if version_proc.kind_of?(Proc)
-      send(version_proc)
+      return version_proc.call(self, *args) if version_proc.kind_of?(Proc)
+      state_accepts_args?(state) ?  send(version_proc, *args) : send(version_proc)
     end
     
   end

data/lib/cell/rails.rb

@@ -49,12 +49,18 @@ module Cell
     abstract!
 
 
-    def initialize(parent_controller, options={})
+    def initialize(parent_controller, *args)
       @parent_controller  = parent_controller
-      @options            = options
-      @opts               = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :options)
+      setup_backwardibility(*args)
     end
-
+    
+    # Some people still like #options and assume it's a hash.
+    def setup_backwardibility(*args)
+      @options = (args.first.is_a?(Hash) and args.size == 1) ? args.first : args
+      @opts    = ActiveSupport::Deprecation::DeprecatedInstanceVariableProxy.new(self, :options)
+    end
+    
+    
     def self.view_context_class
       controller = self
 

data/lib/cell/test_case.rb

@@ -84,8 +84,8 @@ module Cell
       #
       # Example:
       #   assert_equal "Banks kill planet!" cell(:news, :topic => :terror).latest_headline
-      def cell(name, opts={}, &block)
-        cell = ::Cell::Base.create_cell_for(@controller, name, opts)
+      def cell(name, *args, &block)
+        cell = ::Cell::Base.create_cell_for(@controller, name, *args)
         cell.instance_eval &block if block_given?
         cell
       end

data/lib/cells/rails.rb

@@ -17,8 +17,8 @@ module Cells
       #   @box = render_cell(:comments, :top5) do |cell|
       #     cell.markdown! if config.parse_comments?
       #   end
-      def render_cell(name, state, opts={}, &block)
-        ::Cell::Base.render_cell_for(self, name, state, opts, &block)
+      def render_cell(name, state, *args, &block)
+        ::Cell::Base.render_cell_for(self, name, state, *args, &block)
       end
 
       # Expires the cached cell state view, similar to ActionController::expire_fragment.
@@ -49,8 +49,8 @@ module Cells
 
     module ActionView
       # See Cells::Rails::ActionController#render_cell.
-      def render_cell(name, state, opts = {}, &block)
-        ::Cell::Base.render_cell_for(controller, name, state, opts, &block)
+      def render_cell(name, state, *args, &block)
+        ::Cell::Base.render_cell_for(controller, name, state, *args, &block)
       end
     end
 

data/lib/cells/version.rb

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

data/test/cell_module_test.rb

@@ -79,6 +79,9 @@ class CellModuleTest < ActiveSupport::TestCase
         MusicianCell.class_eval do
           @builders = false
         end
+        BassistCell.class_eval do
+          @builders = false
+        end
       end
       
       should "execute the block in controller context" do
@@ -151,11 +154,22 @@ class CellModuleTest < ActiveSupport::TestCase
       assert_equal BassistCell, ::Cell::Base.class_from_cell_name('bassist')
     end
     
-    should "provide state_accepts_args?" do
-      assert_not cell(:bassist).state_accepts_args?(:play)
-      assert(cell(:bassist) do 
-        def listen(args) end 
-      end.state_accepts_args?(:listen))
+    context "#state_accepts_args?" do
+      should "be false if state doesn't want args" do
+        assert_not cell(:bassist).state_accepts_args?(:play)
+      end
+      
+      should "be true for one arg" do
+        assert(cell(:bassist) do 
+          def listen(args) end 
+        end.state_accepts_args?(:listen))
+      end
+      
+      should "be true for multiple arg" do
+        assert(cell(:bassist) do 
+          def listen(what, where) end 
+        end.state_accepts_args?(:listen))
+      end
     end
   end
 end

data/test/rails/caching_test.rb

@@ -230,9 +230,9 @@ class CachingFunctionalTest < ActiveSupport::TestCase
       end
     end
     
-    should "compute the key with the proc" do
-      @class.cache :count do |cell|
-        (cell.options % 2)==0 ? {:count => "even"} : {:count => "odd"}
+    should "compute the key with a block" do
+      @class.cache :count do |cell, int|
+        (int % 2)==0 ? {:count => "even"} : {:count => "odd"}
       end
       # example cache key: cells/director/count/count=odd
       
@@ -242,25 +242,40 @@ class CachingFunctionalTest < ActiveSupport::TestCase
       assert_equal "2", render_cell(:director, :count, 4)
     end
     
+    should "still be able to use options in the block" do
+      @class.class_eval do
+        def count(args)
+          render :text => args[:int]
+        end
+      end
+      
+      @class.cache :count do |cell, i|
+        (cell.options[:int] % 2)==0 ? {:count => "even"} : {:count => "odd"}
+      end
+      
+      assert_equal "1", render_cell(:director, :count, :int => 1)
+      assert_equal "2", render_cell(:director, :count, :int => 2)
+      assert_equal "1", render_cell(:director, :count, :int => 3)
+      assert_equal "2", render_cell(:director, :count, :int => 4)
+    end
+    
     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"}
+        def version(int)
+          (int % 2)==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)
+      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 "allow returning strings, too" do
-      @class.cache :count do |cell|
-        (cell.options % 2)==0 ? "even" : "odd"
+      @class.cache :count do |cell, int|
+        (int % 2)==0 ? "even" : "odd"
       end
       
       assert_equal "1", render_cell(:director, :count, 1)

data/test/rails/integration_test.rb

@@ -4,11 +4,27 @@ class RailsIntegrationTest < ActionController::TestCase
   tests MusicianController
   
   context "A Rails controller" do
-    should "respond to render_cell" do
+    should "respond to #render_cell" do
       get 'promotion'
       assert_equal "That's me, naked <img alt=\"Me\" src=\"/images/me.png\" />", @response.body
     end
     
+    should "respond to #render_cell with arbitrary options" do
+      BassistCell.class_eval do
+        def enjoy(what, where)
+          render :text => "I like #{what} in #{where}."
+        end
+      end
+      
+      @controller.instance_eval do
+        def promotion
+          render :text => render_cell(:bassist, :enjoy, "The Stranglers", "my room")
+        end
+      end
+      get 'promotion'
+      assert_equal "I like The Stranglers in my room.", @response.body
+    end
+    
     should "be able to pass a block to #render_cell" do
       get 'promotion_with_block'
       assert_equal "Doo",       @response.body

metadata

@@ -5,8 +5,8 @@ version: !ruby/object:Gem::Version
   segments: 
   - 3
   - 5
-  - 1
-  version: 3.5.1
+  - 2
+  version: 3.5.2
 platform: ruby
 authors: 
 - Nick Sutterer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-10 00:00:00 +01:00
+date: 2011-02-11 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency