cells 3.7.1 → 3.8.0

data/CHANGES.textile

@@ -1,6 +1,16 @@
+h2. 3.8.0
+
+* @Cell::Base@ got rid of the controller dependency. If you want the @ActionController@ instance around in your cell, use @Cell::Rails@ - this should be the default in a standard Rails setup. However, if you plan on using a Cell in a Rack middleware or don't need the controller, use @Cell::Base@.
+* New API (note that @controller@ isn't the first argument anymore):
+** @Rails.create_cell_for(name, controller)@
+** @Rails.render_cell_for(name, state, controller, *args)@
+* Moved builder methods to @Cell::Builder@ module. 
+* @DEFAULT_VIEW_PATHS@ is now in @Cell::Base@.
+* Removed the monkey-patch that made state-args work in Rails <= 3.0.3. Upgrade to +3.0.4.
+
 h2. 3.7.1
 
-* Runs with Rails 3.2 now. Thanks to Mohammad Satrio [tyok] for fixing.
+* Works with Rails 3.2, too. Hopefully.
 
 h2. 3.7.0
 

data/README.rdoc

@@ -173,6 +173,19 @@ To run your specs we got a rake task, too!
   $ rake spec:cells
 
 
+== Mountable Cells
+
+Cells 3.8 got rid of the ActionController dependency. This essentially means you can mount Cells to routes or use them like a Rack middleware. All you need to do is derive from @Cell::Base@.
+
+  class PostCell < Cell::Base
+  	..
+
+In your @routes.rb@ file, mount the cell like a Rack app.
+
+  match "/posts" => proc { |env|
+    [ 200, {}, [ Cell::Base.render_cell_for(:post, :show) ]]
+  }
+
 == Rails 2.3 note
 
 In order to copy the cells rake tasks to your app, run

data/cells.gemspec

@@ -27,4 +27,5 @@ Gem::Specification.new do |s|
   s.add_development_dependency "haml"
   s.add_development_dependency "slim"
   s.add_development_dependency "tzinfo" # FIXME: why the hell do we need this for 3.1?
+  s.add_development_dependency "minitest"
 end

data/lib/cell.rb

@@ -1,80 +1,2 @@
 module Cell
-  autoload :Caching, 'cell/caching'
-
-  extend ActiveSupport::Concern
-  
-  DEFAULT_VIEW_PATHS = [File.join('app', 'cells')]
-  
-  module ClassMethods
-    # Called in Railtie at initialization time.
-    def setup_view_paths!
-      self.view_paths = self::DEFAULT_VIEW_PATHS
-    end
-    
-    # Main entry point for #render_cell.
-    def render_cell_for(controller, name, state, *args)
-      cell = create_cell_for(controller, name, *args)
-      yield cell if block_given?
-      
-      cell.render_state(state, *args)
-    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, *args)
-      class_from_cell_name(name).build_for(controller, *args)
-    end
-    
-    def build_for(controller, *args)
-      build_class_for(controller, *args).
-      new(controller)
-    end
-    
-    # Adds a builder to the cell class. Builders are used in #render_cell to find out the concrete
-    # class for rendering. This is helpful if you frequently want to render subclasses according
-    # to different circumstances (e.g. login situations) and you don't want to place these deciders in
-    # your view code.
-    #
-    # Passes the opts hash from #render_cell into the block. The block is executed in controller context. 
-    # Multiple build blocks are ORed, if no builder matches the building cell is used.
-    #
-    # Example:
-    #
-    # Consider two different user box cells in your app.
-    #
-    #   class AuthorizedUserBox < UserInfoBox
-    #   end
-    #
-    #   class AdminUserBox < UserInfoBox
-    #   end
-    #
-    # Now you don't want to have deciders all over your views - use a declarative builder.
-    #
-    #   UserInfoBox.build do |opts|
-    #     AuthorizedUserBox if user_signed_in?
-    #     AdminUserBox if admin_signed_in?
-    #   end
-    #
-    # In your view #render_cell will instantiate the right cell for you now.
-    def build(&block)
-      builders << block
-    end
-    
-    # The cell class constant for +cell_name+.
-    def class_from_cell_name(cell_name)
-      "#{cell_name}_cell".classify.constantize
-    end
-    
-  protected
-    def build_class_for(controller, *args)
-      builders.each do |blk|
-        klass = controller.instance_exec(*args, &blk) and return klass
-      end
-      self
-    end
-    
-    def builders
-      @builders ||= []
-    end
-  end
 end

data/lib/cell/base.rb

@@ -31,7 +31,7 @@ module Cell
     
     # Called in Railtie at initialization time.
     def self.setup_view_paths!
-      self.view_paths = DEFAULT_VIEW_PATHS
+      self.view_paths = self::DEFAULT_VIEW_PATHS
     end
     
     def self.controller_path

data/lib/cell/builder.rb

@@ -0,0 +1,71 @@
+module Cell
+  # Contains all methods for dynamically building a cell instance by using decider blocks.
+  module Builder
+    # 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(name, *args)
+      class_from_cell_name(name).build_for(*args)
+    end
+    
+    def build_for(*args)  # DISCUSS: remove?
+      build_class_for(*args).
+      create_cell(*args)
+    end
+    
+    # Adds a builder to the cell class. Builders are used in #render_cell to find out the concrete
+    # class for rendering. This is helpful if you frequently want to render subclasses according
+    # to different circumstances (e.g. login situations) and you don't want to place these deciders in
+    # your view code.
+    #
+    # Passes the opts hash from #render_cell into the block. The block is executed in controller context. 
+    # Multiple build blocks are ORed, if no builder matches the building cell is used.
+    #
+    # Example:
+    #
+    # Consider two different user box cells in your app.
+    #
+    #   class AuthorizedUserBox < UserInfoBox
+    #   end
+    #
+    #   class AdminUserBox < UserInfoBox
+    #   end
+    #
+    # Now you don't want to have deciders all over your views - use a declarative builder.
+    #
+    #   UserInfoBox.build do |opts|
+    #     AuthorizedUserBox if user_signed_in?
+    #     AdminUserBox if admin_signed_in?
+    #   end
+    #
+    # In your view #render_cell will instantiate the right cell for you now.
+    def build(&block)
+      builders << block
+    end
+    
+    # The cell class constant for +cell_name+.
+    def class_from_cell_name(cell_name)
+      "#{cell_name}_cell".classify.constantize
+    end
+    
+    # Override this if you want to receive arguments right in the cell constructor.
+    def create_cell(*args)
+      new
+    end
+    
+  private
+    def build_class_for(*args)
+      builders.each do |blk|
+        klass = run_builder_block(blk, *args) and return klass
+      end
+      self
+    end
+    
+    def run_builder_block(block, *args)
+      block.call(*args)
+    end
+    
+    def builders
+      @builders ||= []
+    end
+  end
+end

data/lib/cell/deprecations.rb

@@ -1,5 +1,6 @@
 module Cell
   # Makes #options available in Cells 3.7, which was removed in favor of state-args.
+  # Note that Deprecations are only available for Cell::Rails.
   module Deprecations
     extend ActiveSupport::Concern
     
@@ -18,7 +19,7 @@ module Cell
     
     module InstanceMethods
       def initialize(parent_controller, *args)
-        super(parent_controller)  # the real Base.new.
+        super(parent_controller)  # the real Rails.new.
         setup_backwardibility(*args)
       end
       

data/lib/cell/rails.rb

@@ -1,141 +1,40 @@
-require 'abstract_controller'
-require 'cell'
+require 'cell/base'
 
 module Cell
-  class Rails < AbstractController::Base
-    include Cell
-    include AbstractController
-    include Rendering, Layouts, Helpers, Callbacks, Translation, Logger
+  class Rails < Base
     include ActionController::RequestForgeryProtection
     
-    if Cells.rails3_0?
-      require 'cell/rails3_0_strategy'
-    elsif Cells.rails3_1_or_more?
-      require 'cell/rails3_1_strategy'
-    end
+    abstract!
     
-    class View < ActionView::Base
-      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
+    module Metal
+      delegate :session, :params, :request, :config, :env, :url_options, :to => :parent_controller
     end
     
+    include Metal
+    
     
-    module Rendering
-      # Invoke the state method for +state+ which usually renders something nice.
-      def render_state(state, *args)
-        process(state, *args)
+    class << self
+      def create_cell(controller, *args)
+        new(controller)
+      end
+      
+    private
+      # Run builder block in controller instance context.
+      def run_builder_block(block, controller, *args)
+        controller.instance_exec(*args, &block)
+      end
+      
+      def render_cell_state(cell, state, *args)
+        args.shift  # remove the controller instance.
+        cell.render_state(state, *args)
       end
     end
-
-
-    module Metal
-      delegate :session, :params, :request, :config, :env, :url_options, :to => :parent_controller
-    end 
-    
-    
-    include VersionStrategy
-    include Metal
-    include Rendering
-    include Caching
     
     attr_reader :parent_controller
-    abstract!
-
-
+    
     def initialize(parent_controller)
       super()
       @parent_controller = parent_controller
     end
-    
-    def self.controller_path
-      @controller_path ||= name.sub(/Cell$/, '').underscore unless anonymous?
-    end
-
-    # Renders the view for the current state and returns the markup.
-    # Don't forget to return the markup itself from the state method.
-    #
-    # === Options
-    # +:view+::   Specifies the name of the view file to render. Defaults to the current state name.
-    # +:layout+:: Renders the state wrapped in the layout. Layouts reside in <tt>app/cells/layouts</tt>.
-    # +:locals+:: Makes the named parameters available as variables in the view.
-    # +:text+::   Just renders plain text.
-    # +:inline+:: Renders an inline template as state view. See ActionView::Base#render for details.
-    # +:file+::   Specifies the name of the file template to render.
-    # +:nothing+:: Doesn't invoke the rendering process.
-    # +:state+::  Instantly invokes another rendering cycle for the passed state and returns. You may pass arbitrary state-args to the called state.  
-    # +:format+:: Sets a different template format, e.g. +:json+. Use this option with caution as it currently modifies the global format variable. This might lead to unexpected subsequent render behaviour due to a design flaw in Rails.
-    #
-    # Example:
-    #  class MusicianCell < ::Cell::Base
-    #    def sing
-    #      # ... laalaa
-    #      render
-    #    end
-    #
-    # renders the view <tt>musician/sing.html</tt>.
-    #
-    #    def sing
-    #      # ... laalaa
-    #      render :view => :shout, :layout => 'metal'
-    #    end
-    #
-    # renders <tt>musician/shout.html</tt> and wrap it in <tt>app/cells/layouts/metal.html.erb</tt>.
-    #
-    # === #render is explicit!
-    # You can also alter the markup from #render. Just remember to return it.
-    #
-    #   def sing
-    #     render + render + render
-    #   end
-    #
-    # will render three concated views.
-    #
-    # === Partials?
-    #
-    # In Cells we abandoned the term 'partial' in favor of plain 'views' - we don't need to distinguish
-    # between both terms. A cell view is both, a view and a kind of partial as it represents only a fragment
-    # of the page.
-    #
-    # Just use <tt>:view</tt> and enjoy.
-    #
-    # === Using states instead of helpers
-    #
-    # Sometimes it's useful to not only render a view but also invoke the associated state. This is 
-    # especially helpful when replacing helpers. Do that with <tt>render :state</tt>.
-    #
-    #   def show_cheap_item(item)
-    #     render if item.price <= 1
-    #   end
-    #
-    # A view could use this state in place of an odd helper.
-    #
-    #   - @items.each do |item|
-    #     = render({:state => :show_cheap_item}, item)
-    #
-    # This calls the state method which in turn will render its view - if the item isn't too expensive.
-    def render(*args)
-      render_view_for(self.action_name, *args)
-    end
-
-  private
-    # Renders the view belonging to the given state. Will raise ActionView::MissingTemplate
-    # if it can't find a view.
-    def render_view_for(state, *args)
-      opts = args.first.is_a?(::Hash) ? args.shift : {}
-      
-      return "" if opts[:nothing]
-      
-      if opts[:state]
-        opts[:text] = render_state(opts.delete(:state), *args)
-      elsif (opts.keys & [:text, :inline, :file]).blank?
-        process_opts_for(opts, state)
-      end
-      
-      render_to_string(opts).html_safe # ActionView::Template::Text doesn't do that for us.
-    end
   end
 end

data/lib/cell/rendering.rb

@@ -0,0 +1,109 @@
+module Cell
+  module Rendering
+    extend ActiveSupport::Concern
+    
+    # Invoke the state method for +state+ which usually renders something nice.
+    def render_state(state, *args)
+      process(state, *args)
+    end
+    
+    # Renders the view for the current state and returns the markup.
+    # Don't forget to return the markup itself from the state method.
+    #
+    # === Options
+    # +:view+::   Specifies the name of the view file to render. Defaults to the current state name.
+    # +:layout+:: Renders the state wrapped in the layout. Layouts reside in <tt>app/cells/layouts</tt>.
+    # +:locals+:: Makes the named parameters available as variables in the view.
+    # +:text+::   Just renders plain text.
+    # +:inline+:: Renders an inline template as state view. See ActionView::Base#render for details.
+    # +:file+::   Specifies the name of the file template to render.
+    # +:nothing+:: Doesn't invoke the rendering process.
+    # +:state+::  Instantly invokes another rendering cycle for the passed state and returns. You may pass arbitrary state-args to the called state.  
+    # +:format+:: Sets a different template format, e.g. +:json+. Use this option with caution as it currently modifies the global format variable. This might lead to unexpected subsequent render behaviour due to a design flaw in Rails.
+    #
+    # Example:
+    #  class MusicianCell < ::Cell::Base
+    #    def sing
+    #      # ... laalaa
+    #      render
+    #    end
+    #
+    # renders the view <tt>musician/sing.html</tt>.
+    #
+    #    def sing
+    #      # ... laalaa
+    #      render :view => :shout, :layout => 'metal'
+    #    end
+    #
+    # renders <tt>musician/shout.html</tt> and wrap it in <tt>app/cells/layouts/metal.html.erb</tt>.
+    #
+    # === #render is explicit!
+    # You can also alter the markup from #render. Just remember to return it.
+    #
+    #   def sing
+    #     render + render + render
+    #   end
+    #
+    # will render three concated views.
+    #
+    # === Partials?
+    #
+    # In Cells we abandoned the term 'partial' in favor of plain 'views' - we don't need to distinguish
+    # between both terms. A cell view is both, a view and a kind of partial as it represents only a fragment
+    # of the page.
+    #
+    # Just use <tt>:view</tt> and enjoy.
+    #
+    # === Using states instead of helpers
+    #
+    # Sometimes it's useful to not only render a view but also invoke the associated state. This is 
+    # especially helpful when replacing helpers. Do that with <tt>render :state</tt>.
+    #
+    #   def show_cheap_item(item)
+    #     render if item.price <= 1
+    #   end
+    #
+    # A view could use this state in place of an odd helper.
+    #
+    #   - @items.each do |item|
+    #     = render({:state => :show_cheap_item}, item)
+    #
+    # This calls the state method which in turn will render its view - if the item isn't too expensive.
+    def render(*args)
+      render_view_for(self.action_name, *args)
+    end
+  
+  private
+    # Renders the view belonging to the given state. Will raise ActionView::MissingTemplate
+    # if it can't find a view.
+    def render_view_for(state, *args)
+      opts = args.first.is_a?(::Hash) ? args.shift : {}
+      
+      return "" if opts[:nothing]
+      
+      if opts[:state]
+        opts[:text] = render_state(opts.delete(:state), *args)
+      elsif (opts.keys & [:text, :inline, :file]).blank?
+        process_opts_for(opts, state)
+      end
+      
+      render_to_string(opts).html_safe # ActionView::Template::Text doesn't do that for us.
+    end
+    
+    
+    module ClassMethods
+      # Main entry point for #render_cell.
+      def render_cell_for(name, state, *args)
+        cell = create_cell_for(name, *args)
+        yield cell if block_given?
+        
+        render_cell_state(cell, state, *args)
+      end
+    
+    private
+      def render_cell_state(cell, state, *args)
+        cell.render_state(state, *args)
+      end
+    end
+  end
+end

data/lib/cell/test_case.rb

@@ -96,7 +96,7 @@ module Cell
       #     assert_select html, "h1", "The latest and greatest!"
       def render_cell(name, state, *args)
         # DISCUSS: should we allow passing a block here, just as in controllers?
-        @subject_cell = ::Cell::Base.create_cell_for(@controller, name, *args)
+        @subject_cell = ::Cell::Rails.create_cell_for(name, @controller, *args)
         @view_assigns = extract_state_ivars_for(@subject_cell) do
           @last_invoke = @subject_cell.render_state(state, *args)
         end
@@ -110,7 +110,7 @@ module Cell
       # Example:
       #   assert_equal "Doo Dumm Dumm..." cell(:bassist).play
       def cell(name, *args, &block)
-        cell = ::Cell::Base.create_cell_for(@controller, name, *args)
+        cell = ::Cell::Rails.create_cell_for(name, @controller, *args)
         cell.instance_eval &block if block_given?
         ActiveSupport::Deprecation.warn("Passing options to TestCase#cell is deprecated, please use state-args in #render_cell.", caller) if args.present?
         cell

data/lib/cells.rb

@@ -68,7 +68,7 @@ module Cells
   #   end
   #
   def self.setup
-    yield(Cell::Base)
+    yield(Cell::Rails)
   end
   
   def self.rails3_0?
@@ -83,7 +83,4 @@ end
 require 'cell/rails'
 require 'cells/railtie'
 require 'cells/rails'
-require 'cells/rails_compat'  # fixes a bug in Rails <3.0.4. # TODO: remove me as soon as we support 3.1, only.
 require 'cell/deprecations'
-
-Cell::Base = Cell::Rails

data/lib/cells/rails.rb

@@ -18,7 +18,7 @@ module Cells
       #     cell.markdown! if config.parse_comments?
       #   end
       def render_cell(name, state, *args, &block)
-        ::Cell::Base.render_cell_for(self, name, state, *args, &block)
+        ::Cell::Rails.render_cell_for(name, state, self, *args, &block)
       end
 
       # Expires the cached cell state view, similar to ActionController::expire_fragment.
@@ -39,7 +39,7 @@ module Cells
       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)
+          cell_class = Cell::Rails.class_from_cell_name(cell_class)
         end
         
         key = cell_class.state_cache_key(state, args)
@@ -50,7 +50,7 @@ module Cells
     module ActionView
       # See Cells::Rails::ActionController#render_cell.
       def render_cell(name, state, *args, &block)
-        ::Cell::Base.render_cell_for(controller, name, state, *args, &block)
+        ::Cell::Rails.render_cell_for(name, state, controller, *args, &block)
       end
     end
 

data/lib/cells/railtie.rb

@@ -3,7 +3,7 @@ require "rails/railtie"
 module Cells
   class Railtie < Rails::Railtie
     initializer "cells.attach_router" do |app|
-      Cell::Rails.class_eval do
+      Cell::Base.class_eval do
         include app.routes.url_helpers
       end
     end

data/lib/cells/version.rb

@@ -1,3 +1,3 @@
 module Cells
-  VERSION = '3.7.1'
+  VERSION = '3.8.0'
 end

data/test/app/cells/bassist_cell.rb

@@ -1,4 +1,4 @@
-class BassistCell < Cell::Base
+class BassistCell < Cell::Rails
   def play; render; end
 
   def shout(args)

data/test/app/cells/club_security/guard_cell.rb

@@ -1,6 +1,6 @@
-class ClubSecurity::GuardCell < Cell::Base
+class ClubSecurity::GuardCell < Cell::Rails
   helper do
     def irritate; end
   end
   def help; render; end
-end
+end

data/test/app/cells/club_security/medic_cell.rb

@@ -1,8 +1,8 @@
-class ClubSecurity::MedicCell < Cell::Base
+class ClubSecurity::MedicCell < Cell::Rails
   module NiceGuy
     def smile; end
   end
 
   helper NiceGuy
   def help; render; end
-end
+end

data/test/app/cells/shouter/sing.html.erb

@@ -0,0 +1 @@
+AAAaaargh!

data/test/cell_module_test.rb

@@ -1,6 +1,6 @@
 require 'test_helper'
 
-class MusicianCell < Cell::Base
+class MusicianCell < Cell::Rails
 end
 
 class PianistCell < MusicianCell
@@ -9,21 +9,51 @@ end
 class SingerCell < MusicianCell
 end
 
+# Used in CellBaseTest.
+class ShouterCell < Cell::Base
+  def sing
+    render
+  end
+end
+
+
+class CellBaseTest < MiniTest::Spec
+  describe "Cell::Base" do
+    it "still have a working #url_for" do
+      cell = Cell::Base.new
+      cell.instance_eval do
+        # You can use #default_url_options.
+        def default_url_options
+          {:host => "cells-project.org"}
+        end
+        
+      end
+      # You could also use a *_url or *_path helper method here.
+      assert_equal "http://cells-project.org/dashboard/show", cell.url_for(:action => :show, :controller => :dashboard)
+    end
+    
+    describe ".render_cell_for" do
+      it "invokes controller-less cell" do
+        Cell::Base.view_paths= ["test/app/cells"]
+        assert_equal "AAAaaargh!\n", Cell::Base.render_cell_for(:shouter, :sing)
+      end
+    end
+  end
+end
+
 
 class CellModuleTest < ActiveSupport::TestCase
   include Cell::TestCase::TestMethods
-  
-  context "Cell::Base" do
-    
+  context "Cell::Rails" do
     # FUNCTIONAL:
     context "render_cell_for" do
       should "render the actual cell" do
-        assert_equal "Doo", Cell::Base.render_cell_for(@controller, :bassist, :play)
+        assert_equal "Doo", Cell::Rails.render_cell_for(:bassist, :play, @controller)
       end
       
       should "accept a block, passing the cell instance" do
         flag = false
-        html = Cell::Base.render_cell_for(@controller, :bassist, :play) do |cell|
+        html = Cell::Rails.render_cell_for(:bassist, :play, @controller) do |cell|
           assert_equal BassistCell, cell.class
           flag = true
         end
@@ -41,7 +71,7 @@ class CellModuleTest < ActiveSupport::TestCase
           end
         end
         
-        assert_instance_of BassistCell, Cell::Base.create_cell_for(@controller, "cell_module_test/drummer", :play)
+        assert_instance_of BassistCell, Cell::Rails.create_cell_for("cell_module_test/drummer", :play, @controller)
       end
     end
     
@@ -67,13 +97,13 @@ class CellModuleTest < ActiveSupport::TestCase
       
       should "execute the block in controller context" do
         @controller.bassist = true
-        assert_is_a BassistCell,  Cell::Base.create_cell_for(@controller, :musician, {})
+        assert_is_a BassistCell,  Cell::Rails.create_cell_for(:musician, @controller)
       end
       
       should "limit the builder to the receiving class" do
-        assert_is_a PianistCell,   Cell::Base.create_cell_for(@controller, :pianist, {})   # don't inherit anything.
+        assert_is_a PianistCell,   Cell::Rails.create_cell_for(:pianist, @controller)   # don't inherit anything.
         @controller.bassist = true
-        assert_is_a BassistCell,   Cell::Base.create_cell_for(@controller, :musician, {})
+        assert_is_a BassistCell,   Cell::Rails.create_cell_for(:musician, @controller)
       end
       
       should "chain build blocks and execute them by ORing them in the same order" do
@@ -85,13 +115,13 @@ class CellModuleTest < ActiveSupport::TestCase
           UnknownCell # should never be executed.
         end
         
-        assert_is_a PianistCell, Cell::Base.create_cell_for(@controller, :musician, {})  # bassist is false.
+        assert_is_a PianistCell, Cell::Rails.create_cell_for(:musician, @controller)  # bassist is false.
         @controller.bassist = true
-        assert_is_a BassistCell, Cell::Base.create_cell_for(@controller, :musician, {})
+        assert_is_a BassistCell, Cell::Rails.create_cell_for(:musician, @controller)
       end
       
       should "use the original cell if no builder matches" do
-        assert_is_a MusicianCell, Cell::Base.create_cell_for(@controller, :musician, {})  # bassist is false.
+        assert_is_a MusicianCell, Cell::Rails.create_cell_for(:musician, @controller)  # bassist is false.
       end
       
       should "stop at the first builder returning a valid cell" do
@@ -102,12 +132,12 @@ class CellModuleTest < ActiveSupport::TestCase
         BassistCell.build do |opts|
           SingerCell if opts[:sing_the_song]
         end
-        assert_kind_of BassistCell, Cell::Base.create_cell_for(@controller, :bassist, {})
-        assert_kind_of SingerCell,  Cell::Base.create_cell_for(@controller, :bassist, {:sing_the_song => true})
+        assert_kind_of BassistCell, Cell::Rails.create_cell_for(:bassist, @controller, {})
+        assert_kind_of SingerCell,  Cell::Rails.create_cell_for(:bassist, @controller, {:sing_the_song => true})
       end
       
       should "create the original target class if no block matches" do
-        assert_kind_of PianistCell, Cell::Base.create_cell_for(@controller, :pianist, {})
+        assert_kind_of PianistCell, Cell::Rails.create_cell_for(:pianist, @controller)
       end
       
       should "builders should return an empty array per default" do
@@ -116,7 +146,7 @@ class CellModuleTest < ActiveSupport::TestCase
     end
     
     should "provide class_from_cell_name" do
-      assert_equal BassistCell, ::Cell::Base.class_from_cell_name('bassist')
+      assert_equal BassistCell, ::Cell::Rails.class_from_cell_name('bassist')
     end
     
     if Cells.rails3_0?
@@ -129,7 +159,7 @@ class CellModuleTest < ActiveSupport::TestCase
       end
       
       should "provide cell_name for modules, too" do
-        class SingerCell < Cell::Base
+        class SingerCell < Cell::Rails
         end
         
         assert_equal "cell_module_test/singer", CellModuleTest::SingerCell.cell_name

data/test/cells_module_test.rb

@@ -4,11 +4,11 @@ class CellsModuleTest < ActiveSupport::TestCase
   context "Cells" do
     context "view_paths" do
       setup do
-        @old_view_paths = Cell::Base.view_paths.clone
+        @old_view_paths = Cell::Rails.view_paths.clone
       end
       
       teardown do
-        Cell::Base.view_paths = @old_view_paths
+        Cell::Rails.view_paths = @old_view_paths
       end
       
       should "provide .setup" do
@@ -16,7 +16,7 @@ class CellsModuleTest < ActiveSupport::TestCase
           c.append_view_path "/road/to/nowhere"
         end
         
-        assert_equal "/road/to/nowhere", Cell::Base.view_paths.last.to_s
+        assert_equal "/road/to/nowhere", Cell::Rails.view_paths.last.to_s
       end
     end
     

data/test/deprecations_test.rb

@@ -37,7 +37,7 @@ class DeprecationsTest < ActiveSupport::TestCase
           render :text => options[:note]
         end
       end
-      assert_equal "C-minor", Cell::Base.render_cell_for(@controller, :songwriter, :listen, :note => "C-minor")
+      assert_equal "C-minor", Cell::Rails.render_cell_for(:songwriter, :listen, @controller, :note => "C-minor")
     end
       
     should "pass options as state-args and still set #options otherwise" do
@@ -46,7 +46,7 @@ class DeprecationsTest < ActiveSupport::TestCase
           render :text => args[:note] + options[:note].to_s
         end
       end
-      assert_equal "C-minorC-minor", Cell::Base.render_cell_for(@controller, :songwriter, :listen, :note => "C-minor")
+      assert_equal "C-minorC-minor", Cell::Rails.render_cell_for(:songwriter, :listen, @controller, :note => "C-minor")
     end
   end
   

data/test/helper_test.rb

@@ -7,7 +7,7 @@ module StringHelper
   def pick; "plong"; end
 end
 
-class DrummerCell < Cell::Base
+class DrummerCell < Cell::Rails
   helper StringHelper
           
   def assist

data/test/rails/caching_test.rb

@@ -109,11 +109,11 @@ class CachingUnitTest < ActiveSupport::TestCase
     
     should "accept cache options" do
       key = @class.state_cache_key(:tock, :volume => 9)
-      assert Cell::Base.cache_store.write(key, 'ONE!')
+      assert Cell::Rails.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)
+      assert_not ::Cell::Rails.cache_store.read(key)
     end
     
     should "raise a deprecation notice when passing in a :symbol" do

data/test/rails/cells_test.rb

@@ -48,13 +48,13 @@ class RailsCellsTest < ActiveSupport::TestCase
   
   context "A rails cell" do
     should "respond to DEFAULT_VIEW_PATHS" do
-      assert_equal ["app/cells"], Cell::Base::DEFAULT_VIEW_PATHS
+      assert_equal ["app/cells"], Cell::Rails::DEFAULT_VIEW_PATHS
     end
     
     should "respond to .setup_view_paths!" do
-      swap( Cell::Base, :view_paths => [])  do
-        Cell::Base.setup_view_paths!
-        assert_equal ActionView::PathSet.new(Cell::Rails::DEFAULT_VIEW_PATHS), Cell::Base.view_paths
+      swap( Cell::Rails, :view_paths => [])  do
+        Cell::Rails.setup_view_paths!
+        assert_equal ActionView::PathSet.new(Cell::Rails::DEFAULT_VIEW_PATHS), Cell::Rails.view_paths
       end
     end
     
@@ -63,8 +63,8 @@ class RailsCellsTest < ActiveSupport::TestCase
     end
     
     should "respond to view_paths=" do
-      swap( Cell::Base, :view_paths => ['you', 'are', 'here'])  do
-        assert_kind_of ActionView::PathSet, Cell::Base.view_paths, "must not wipe out the PathSet"
+      swap( Cell::Rails, :view_paths => ['you', 'are', 'here'])  do
+        assert_kind_of ActionView::PathSet, Cell::Rails.view_paths, "must not wipe out the PathSet"
       end
     end
     

data/test/test_case_test.rb

@@ -12,8 +12,14 @@ class TestCaseTest < Cell::TestCase
       end
     end
     
-    should "respond to #render_cell" do
-      assert_equal "Doo", render_cell(:bassist, :play)
+    context "#render_cell" do
+      should "invokes the state" do
+        assert_equal "Doo", render_cell(:bassist, :play)
+      end
+      
+      should "accept state args" do
+        assert_equal "*shouts* Listen!\n", render_cell(:bassist, :shout, :words => "Listen!")
+      end
     end
     
     should "respond to #assert_selector with 3 args" do

data/test/test_helper.rb

@@ -2,6 +2,7 @@
 require 'rubygems'
 require 'test/unit'
 require 'shoulda'
+require 'minitest/spec'
 
 # wycats says...
 require 'bundler'

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 3
-  - 7
-  - 1
-  version: 3.7.1
+  - 8
+  - 0
+  version: 3.8.0
 platform: ruby
 authors: 
 - Nick Sutterer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-12-20 00:00:00 +01:00
+date: 2011-12-21 00:00:00 +01:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -110,6 +110,19 @@ dependencies:
         version: "0"
   type: :development
   version_requirements: *id007
+- !ruby/object:Gem::Dependency 
+  name: minitest
+  prerelease: false
+  requirement: &id008 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id008
 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
@@ -130,16 +143,17 @@ files:
 - cells.gemspec
 - lib/cell.rb
 - lib/cell/base.rb
+- lib/cell/builder.rb
 - lib/cell/caching.rb
 - lib/cell/deprecations.rb
 - lib/cell/rails.rb
 - lib/cell/rails3_0_strategy.rb
 - lib/cell/rails3_1_strategy.rb
+- lib/cell/rendering.rb
 - lib/cell/test_case.rb
 - lib/cells.rb
 - lib/cells/cells.rake
 - lib/cells/rails.rb
-- lib/cells/rails_compat.rb
 - lib/cells/railtie.rb
 - lib/cells/version.rb
 - lib/generators/USAGE
@@ -182,6 +196,7 @@ files:
 - test/app/cells/layouts/metal.html.erb
 - test/app/cells/producer/capture.html.erb
 - test/app/cells/producer/content_for.html.erb
+- test/app/cells/shouter/sing.html.erb
 - test/app/cells/trumpeter/promote.html.erb
 - test/app/cells/trumpeter_cell.rb
 - test/cell_generator_test.rb

data/lib/cells/rails_compat.rb

@@ -1,12 +0,0 @@
-# TODO: remove me when Cells supports 3.1, only.
-if Rails::VERSION::MINOR == 0 and Rails::VERSION::TINY <= 3
-  module AbstractController
-    module Callbacks
-      def process_action(method_name, *args)  # Fixed in 3.0.4.
-        run_callbacks(:process_action, method_name) do
-          super
-        end
-      end
-    end
-  end
-end