cells 3.3.10 → 3.4.0.beta1

data/lib/cells/rails.rb

@@ -1,11 +1,72 @@
 # encoding: utf-8
-require 'cells/rails/action_controller'
-require 'cells/rails/action_view'
 
-Cell::Base.class_eval do
-  helper ::ApplicationHelper if defined?(::ApplicationHelper)
+# These Methods are automatically added to all Controllers and Views when
+# the cells plugin is loaded.
+module Cells
+  module Rails
+    module ActionController
+      # Equivalent to ActionController#render_to_string, except it renders a cell
+      # rather than a regular templates.
+      def render_cell(name, state, opts={})
+        ::Cell::Base.render_cell_for(self, name, state, opts)
+      end
+
+      # Expires the cached cell state view, similar to ActionController::expire_fragment.
+      # Usually, this method is used in Sweepers.
+      # Beside the obvious first two args <tt>cell_name</tt> and <tt>state</tt> you can pass
+      # in additional cache key <tt>args</tt> and cache store specific <tt>opts</tt>.
+      #
+      # Example:
+      #
+      #  class ListSweeper < ActionController::Caching::Sweeper
+      #   observe List, Item
+      #
+      #   def after_save(record)
+      #     expire_cell_state :my_listing, :display_list
+      #   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)
+      end
+    end
+    
+    
+    module ActionView
+      # Call a cell state and return its rendered view.
+      #
+      # ERB example:
+      #   <div id="login">
+      #     <%= render_cell :user, :login_prompt, :message => "Please login" %>
+      #   </div>
+      #
+      # If you have a <tt>UserCell</tt> cell in <tt>app/cells/user_cell.rb</tt>, which has a
+      # <tt>UserCell#login_prompt</tt> method, this will call that method and then will
+      # find the view <tt>app/cells/user/login_prompt.html.erb</tt> and render it. This is
+      # called the <tt>:login_prompt</tt> <em>state</em> in Cells terminology.
+      #
+      # If this view file looks like this:
+      #   <h1><%= @opts[:message] %></h1>
+      #   <label>name: <input name="user[name]" /></label>
+      #   <label>password: <input name="user[password]" /></label>
+      #
+      # The resulting view in the controller will be roughly equivalent to:
+      #   <div id="login">
+      #     <h1><%= "Please login" %></h1>
+      #     <label>name: <input name="user[name]" /></label>
+      #     <label>password: <input name="user[password]" /></label>
+      #   </div>
+      def render_cell(name, state, opts = {})
+        ::Cell::Base.render_cell_for(controller, name, state, opts)
+      end
+    end
+
+    
+  end
 end
 
+
 # Add extended ActionController behaviour.
 ActionController::Base.class_eval do
   include ::Cells::Rails::ActionController

data/lib/cells/version.rb

@@ -1,3 +1,5 @@
+# encoding: utf-8
+
 module Cells
-  VERSION = '3.3.10'
+  VERSION = '3.4.0.beta1'
 end

data/rails_generators/cell/cell_generator.rb

@@ -1,51 +1,63 @@
-require 'rails_generator/generators/components/controller/controller_generator'
-
-class CellGenerator < ControllerGenerator
-
-  attr_reader :template_type
-
-  def initialize(runtime_args, runtime_options = {})
-    super
-    @template_type = options[:haml] ? :haml : :erb
+#require 'rails_generator/generators/components/controller/controller_generator'
+require 'rails/generators/named_base'
+module Cells
+module Generators
+class CellGenerator < ::Rails::Generators::NamedBase
+  argument :actions, :type => :array, :default => [], :banner => "action action"
+  check_class_collision :suffix => "Cell"
+
+  def create_cell_files
+    template 'cell.rb', File.join('app/cells', class_path, "#{file_name}_cell.rb")
   end
 
-  def manifest
-    record do |m|
-      # Check for class naming collisions.
-      m.class_collisions class_path, "#{class_name}Cell"
+  hook_for :template_engine
+  hook_for :test_framework
+  
+  source_root File.expand_path(File.join(File.dirname(__FILE__), 'templates'))
+  
+      
+  #attr_reader :template_type
+
+  #def initialize(runtime_args, runtime_options = {})
+  #  super
+  #  @template_type = options[:haml] ? :haml : :erb
+  #end
 
+  #def ___manifest
       # Directories
-      m.directory File.join('app/cells', class_path)
-      m.directory File.join('app/cells', class_path, file_name)
-      m.directory File.join('test/cells')
+      #m.directory File.join('app/cells', class_path)
+      #m.directory File.join('app/cells', class_path, file_name)
+      #m.directory File.join('test/cells')
       
       # Cell
-      m.template 'cell.rb', File.join('app/cells', class_path, "#{file_name}_cell.rb")
+      #m.template 'cell.rb', File.join('app/cells', class_path, "#{file_name}_cell.rb")
 
       # View template for each action.
-      actions.each do |action|
-        path = File.join('app/cells', class_path, file_name, "#{action}.html.#{template_type}")
-        m.template "view.html.#{template_type}", path, :assigns => { :action => action, :path => path }
-      end
+      #actions.each do |action|
+      #  path = File.join('app/cells', class_path, file_name, "#{action}.html.#{template_type}")
+      #  m.template "view.html.#{template_type}", path, :assigns => { :action => action, :path => path }
+      #end
       
       # Functional test for the widget.
-      m.template 'cell_test.rb', File.join('test/cells/', "#{file_name}_cell_test.rb"), :assigns => {:states => actions}
-    end
-  end
+      #m.template 'cell_test.rb', File.join('test/cells/', "#{file_name}_cell_test.rb"), :assigns => {:states => actions}
+    #end
+  #end
 
-  def add_options!(opt)
-    opt.separator ''
-    opt.separator 'Options:'
+  #def add_options!(opt)
+  #  opt.separator ''
+  #  opt.separator 'Options:'#
 
     # Allow option to generate HAML views instead of ERB.
-    opt.on('--haml',
-    "Generate HAML output instead of the default ERB.") do |v|
-      options[:haml] = v
-    end
-  end
+    #opt.on('--haml',
+    #"Generate HAML output instead of the default ERB.") do |v|
+    #  options[:haml] = v
+    #end
+  #end
 
-  def banner
-    "Usage: #{$0} cell NAME a_view another_view ... [--haml]"
-  end
+  #def banner
+  #  "Usage: #{$0} cell NAME a_view another_view ... [--haml]"
+  #end
 
 end
+
+end;end

data/rails_generators/cell/templates/cell.rb

@@ -1,4 +1,4 @@
-class <%= class_name %>Cell < ::Cell::Base
+class <%= class_name %>Cell < Cell::Rails
 
 <% for action in actions -%>
   def <%= action %>

data/rails_generators/cells_install/cells_install_generator.rb

@@ -1,10 +1,12 @@
+# encoding: utf-8
+
 class CellsInstallGenerator < Rails::Generator::Base
+
   def manifest
     record do |m|
       m.directory File.join('config', 'initializers')
-      m.directory File.join('lib', 'tasks')
       m.template  'initializer.rb', File.join('config', 'initializers', 'cells.rb')
-      m.template  'tasks.rake', File.join('lib', 'tasks', 'cells.rake')
     end
   end
-end
+
+end

data/rails_generators/erb/cell_generator.rb

@@ -0,0 +1,20 @@
+require 'rails/generators/erb'
+
+module Erb
+  module Generators
+    class CellGenerator < Base
+      argument :actions, :type => :array, :default => [], :banner => "action action"
+
+      def copy_view_files
+        base_path = File.join("app/cells", class_path, file_name)
+        empty_directory base_path
+puts base_path.inspect
+        actions.each do |action|
+          @action = action
+          @path = File.join(base_path, filename_with_extensions(action))
+          template filename_with_extensions(:view), @path
+        end
+      end
+    end
+  end
+end

data/test/active_helper_test.rb

@@ -6,6 +6,7 @@ class ActiveHelperTest < ActiveSupport::TestCase
   context "The Cell::Base class" do
     setup do
       require 'active_helper'
+      require 'active_helper/rails'
       class FingeringHelper < ActiveHelper::Base
         provides :finger
       end

data/test/app/cells/bad_guitarist_cell.rb

@@ -0,0 +1,2 @@
+class BadGuitaristCell < BassistCell
+end

data/test/app/cells/bassist_cell.rb

@@ -1,3 +1,3 @@
 class BassistCell < Cell::Base
-  
+  def play; render; end
 end

data/test/app/controllers/musician_controller.rb

@@ -0,0 +1,16 @@
+class MusicianController < ActionController::Base
+  def promotion
+    render :text => render_cell(:bassist, :play)
+  end
+  
+  def featured
+    self.view_paths << File.expand_path(File.join(File.dirname(__FILE__), '../views'))
+  end
+  
+  def skills
+    render :text => render_cell(:bassist, :listen)
+  end
+  
+
+  def action_method?(name); true; end ### FIXME: fixes NameError: undefined local variable or method `_router' for MusicianController:Class
+end

data/test/assertions_helper_test.rb

@@ -4,40 +4,30 @@ require File.join(File.dirname(__FILE__), 'test_helper')
 class AssertionsHelperTest < ActionController::TestCase
   context "A TestCase" do
     setup do
-      TestCell.class_eval do
-        def beep; render; end
-      end
-    end
-    
-    context "calling #cell_mock" do
-      should "return a cell instance" do
-        assert_kind_of Cell::Base, cell_mock
-      end
-      
-      should "accept a block" do
-        assert_respond_to cell_mock { def beep; end}, :beep
+      BassistCell.class_eval do
+        def play; render; end
       end
     end
     
     should "respond to #render_cell" do
-      assert_equal "<h1>beep!</h1>", render_cell(:test, :beep)
+      assert_equal "Doo", render_cell(:bassist, :play)
     end
     
     should "respond to #assert_selekt" do
-      assert_selekt render_cell(:test, :beep), "h1", "beep!"
+      assert_selekt "<p>Doo</p>", "p", "Doo"
     end
     
     should "respond to #cell" do
-      assert_kind_of TestCell, cell(:test)
-      assert_not cell(:test).respond_to? :opts
+      assert_kind_of BassistCell, cell(:bassist)
+      assert_not cell(:bassist).respond_to? :opts
     end
     
     should "respond to #cell with a block" do
-      assert_respond_to cell(:test) { def opts; @opts; end }, :opts
+      assert_respond_to cell(:bassist) { def opts; @opts; end }, :opts
     end
     
     should "respond to #cell with options and block" do
-      assert_equal({:topic => :peace}, cell(:test, :topic => :peace) { def opts; @opts; end }.opts)
+      assert_equal({:topic => :peace}, cell(:bassist, :topic => :peace) { def opts; @opts; end }.opts)
     end
   end
 end

data/test/base_methods_test.rb

@@ -0,0 +1,40 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class BaseMethodsTest < ActiveSupport::TestCase
+  context "Cell::Base" do
+    
+    should "provide AbstractBase.render_cell_for" do
+      assert_equal "Doo", Cell::Base.render_cell_for(@controller, :bassist, :play)
+    end
+    
+    should "provide possible_paths_for_state" do
+      assert_equal ["bad_guitarist/play", "bassist/play", "cell/rails/play"], cell(:bad_guitarist).possible_paths_for_state(:play)
+    end
+    
+    should "provide cell_name" do
+      assert_equal 'bassist', cell(:bassist).cell_name
+      assert_equal cell(:bassist).cell_name, BassistCell.cell_name
+    end
+    
+    should "provide cell_name for modules, too" do
+      class SingerCell
+        include Cell::BaseMethods
+      end
+      
+      assert_equal "base_methods_test/singer", BaseMethodsTest::SingerCell.cell_name
+    end
+    
+    
+    should "provide class_from_cell_name" do
+      assert_equal BassistCell, ::Cell::Base.class_from_cell_name('bassist')
+    end
+    
+    should "provide AbstractBase.default_template_format" do
+      cell(:bassist).class.default_template_format = :js
+      
+      assert_equal :html, ::Cell::Base.default_template_format
+      assert_equal :js, cell(:bassist).class.default_template_format
+    end
+    
+  end
+end

data/test/cell_generator_test.rb

@@ -1,33 +1,45 @@
 require File.join(File.dirname(__FILE__), *%w[test_helper])
-require 'rails_generator'
-require 'rails_generator/scripts/generate'
 
-# for some reasons the "autoloading" in Rails::Generator::Lookup doesn't work:
-Rails::Generator::Base.append_sources Rails::Generator::PathSource.new(:cells, File.join(File.dirname(__FILE__)+'/../rails_generators'))
+#require 'rails/generators/test_unit'
 
-class CellGeneratorTest < Test::Unit::TestCase
+
+require '/home/nick/projects/rails/railties/lib/rails/test/isolation/abstract_unit'
+#require '/home/nick/projects/rails/railties/test/generators/generators_test_helper'
+require 'rails/generators'
+require 'rails_generators/cell/cell_generator'
+module Rails
+  def self.root
+    @root ||= File.expand_path(File.join(File.dirname(__FILE__), '..', 'fixtures'))
+  end
+end
+
+
+class CellGeneratorTest < Rails::Generators::TestCase
+  destination File.join(Rails.root, "tmp")
+  setup :prepare_destination
+  tests ::Cells::Generators::CellGenerator
+  
+  
   context "Running script/generate cell" do
-    setup do
-      FileUtils.mkdir_p(fake_rails_root)
-      @original_files = file_list
-    end
-    
-    teardown do
-      FileUtils.rm_r(fake_rails_root) 
-    end
-    
     context "Blog post latest" do
       should "create the standard assets" do
-        Rails::Generator::Scripts::Generate.new.run(%w(cell Blog post latest), :destination => fake_rails_root)
-        files = (file_list - @original_files)
-        assert files.include?(fake_rails_root+"/app/cells/blog_cell.rb")
-        assert files.include?(fake_rails_root+"/app/cells/blog/post.html.erb")
-        assert files.include?(fake_rails_root+"/app/cells/blog/latest.html.erb")
-        assert files.include?(fake_rails_root+"/test/cells/blog_cell_test.rb")
+        
+        require "#{app_path}/config/environment"  # we need Rails.application
+        
+
+        run_generator ["Blog", "post", "latest"]
+        
+        assert_file "app/cells/blog_cell.rb", /class BlogCell < Cell::Rails/
+        assert_file "app/cells/blog/post.html.erb", %r(app/cells/blog/post\.html\.erb)
+        assert_file "app/cells/blog/latest.html.erb", %r(app/cells/blog/latest\.html\.erb)
+
+        #assert files.include?(fake_rails_root+"/app/cells/blog/post.html.erb")
+        #assert files.include?(fake_rails_root+"/app/cells/blog/latest.html.erb")
+        #assert files.include?(fake_rails_root+"/test/cells/blog_cell_test.rb")
       end
       
       should "create haml assets with --haml" do
-        Rails::Generator::Scripts::Generate.new.run(%w(cell Blog post latest --haml), :destination => fake_rails_root)
+        run_generator ["Blog", "post", "latest", "--haml"]
         files = (file_list - @original_files)
         assert files.include?(fake_rails_root+"/app/cells/blog_cell.rb")
         assert files.include?(fake_rails_root+"/app/cells/blog/post.html.haml")

data/test/helper_test.rb

@@ -1,138 +1,46 @@
 # encoding: utf-8
 require File.join(File.dirname(__FILE__), 'test_helper')
 
-module CellsTestHelper
-  def a_mysterious_helper_method
-    'mysterious'
-  end
+module StringHelper
+  def pick; "plong"; end
 end
 
-module AnotherHelper
-  def senseless_helper_method
-    'senseless'
+class DrummerCell < Cell::Base
+  helper StringHelper
+          
+  def assist
+    render :inline => "<%= pick %>"
   end
 end
 
-class HelperUsingCell < ::Cell::Base
-  helper CellsTestHelper
-  helper_method :my_helper_method
-
-  def state_with_helper_invocation
-    render
-  end
-
-  def state_with_automatic_helper_invocation
-    render
-  end
-
-  def state_with_helper_method_invocation
-    render
-  end
-
-  def state_using_application_helper
-    render
-  end
-
-  protected
-
-    def my_helper_method
-      'helped by a method'
-    end
-end
-
-class TwoHelpersIncludingCell < HelperUsingCell
-  helper AnotherHelper
-
-  def state_using_another_helper
-    render
-  end
-end
-
-class HelperUsingSubCell < HelperUsingCell
-end
 
 class HelperTest < ActionController::TestCase
-  def test_helper
-    cell = HelperUsingCell.new(@controller)
-
-    c = cell.render_state(:state_with_helper_invocation)
-    assert_selekt c, 'p#stateWithHelperInvocation', 'mysterious'
-  end
-
-  # ActiveSupport::Dependencies.load_paths << File.join(File.dirname(__FILE__), 'helpers')
-  # test if the HelperUsingCellHelper is automatically included:
-
-  ## FIXME: currently loading should happen in render_view_for_state, since
-  #   there seems to be no automatic mechanism.
-  def dont_test_auto_helper
-    # ActionController::Base.helpers_dir = File.join(File.dirname(__FILE__), 'helpers')
-    ::Cell::Base.helpers_dir = File.join(File.dirname(__FILE__), 'app', 'helpers')
-    setup
-
-    cell = HelperUsingCell.new(@controller)
-    c = cell.render_state(:state_with_automatic_helper_invocation)
-
-    assert_selekt c, 'p#stateWithAutomaticHelperInvocation', 'automatic'
-  end
-
-  def test_helper_method
-    cell = HelperUsingCell.new(@controller)
-    c = cell.render_state(:state_with_helper_method_invocation)
-
-    assert_selekt c, 'p#stateWithHelperMethodInvocation', 'helped by a method'
-  end
-
-  def test_helper_with_subclassing
-    cell = HelperUsingSubCell.new(@controller)
-    c = cell.render_state(:state_with_helper_invocation)
-
-    assert_selekt c, 'p#stateWithHelperInvocation', 'mysterious'
-  end
-
-  def test_helper_including_and_cleanup
-    # this cell includes a helper, and uses it:
-    cell = HelperUsingCell.new(@controller)
-    c = cell.render_state(:state_with_helper_invocation)
-
-    assert_selekt c, 'p#stateWithHelperInvocation', 'mysterious'
-
-    # this cell doesn't include the helper, but uses it anyway, which should
-    # produce an error:
-    cell = TestCell.new(@controller)
-
-    # assert_raises (NameError) do
-    assert_raises (::ActionView::TemplateError) do
-      cell.render_state(:state_with_not_included_helper_method)
+  context "a cell view" do
+    should "have access to all helpers" do
+      BassistCell.class_eval do
+        def assist
+          render :inline => "<%= submit_tag %>"
+        end
+      end
+      
+      assert_equal "<input name=\"commit\" type=\"submit\" value=\"Save changes\" />", render_cell(:bassist, :assist)
     end
-  end
-
-  def test_helpers_included_on_different_inheritance_levels
-    cell = TwoHelpersIncludingCell.new(@controller)
-    c = cell.render_state(:state_with_helper_invocation)
-
-    assert_selekt c, 'p#stateWithHelperInvocation', 'mysterious'
-
-    c = cell.render_state(:state_using_another_helper)
-
-    assert_selekt c, 'p#stateUsingAnotherHelper', 'senseless'
-  end
-
-  def test_application_helper
-    cell = HelperUsingCell.new(@controller)
-    c = cell.render_state(:state_using_application_helper)
-
-    assert_selekt c, 'p#stateUsingApplicationHelper', 'global'
-  end
-
-  def test_rails_helper_url_for
-    cell = HelperUsingCell.new(@controller)
-    cell.instance_eval do
-      def state_with_url_for
-        render :inline => "<%= url_for '/test' %>"
+    
+    should "have access to methods declared with helper_method" do
+      BassistCell.class_eval do
+        def help; "Great!"; end
+        helper_method :help
+          
+        def assist
+          render :inline => "<%= help %>"
+        end
       end
+      
+      assert_equal "Great!", render_cell(:bassist, :assist)
+    end
+    
+    should "have access to methods provided by helper" do
+      assert_equal "plong", render_cell(:drummer, :assist)
     end
-    c = cell.render_state(:state_with_url_for)
-
-    assert_equal '/test', c
   end
 end