cells 3.4.0.beta1 → 3.4.0.beta2

data/Gemfile

@@ -1,6 +1,10 @@
 source :gemcutter
-#gem "rails" , :git => "http://github.com/rails/rails.git"
 gem 'sqlite3-ruby', '1.2.5', :require => 'sqlite3'	# needed in router_test, whatever.
 
-gem "rails" , :path => "/home/nick/projects/rails"
-#gem "railties"
+#gem "rails" , :path => "/home/nick/projects/rails"
+gem "rails" #, :git => "http://github.com/rails/rails.git"
+gem "haml"
+
+group :test do
+  gem "shoulda"
+end

data/Gemfile.lock

@@ -0,0 +1,77 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    abstract (1.0.0)
+    actionmailer (3.0.0)
+      actionpack (= 3.0.0)
+      mail (~> 2.2.5)
+    actionpack (3.0.0)
+      activemodel (= 3.0.0)
+      activesupport (= 3.0.0)
+      builder (~> 2.1.2)
+      erubis (~> 2.6.6)
+      i18n (~> 0.4.1)
+      rack (~> 1.2.1)
+      rack-mount (~> 0.6.12)
+      rack-test (~> 0.5.4)
+      tzinfo (~> 0.3.23)
+    activemodel (3.0.0)
+      activesupport (= 3.0.0)
+      builder (~> 2.1.2)
+      i18n (~> 0.4.1)
+    activerecord (3.0.0)
+      activemodel (= 3.0.0)
+      activesupport (= 3.0.0)
+      arel (~> 1.0.0)
+      tzinfo (~> 0.3.23)
+    activeresource (3.0.0)
+      activemodel (= 3.0.0)
+      activesupport (= 3.0.0)
+    activesupport (3.0.0)
+    arel (1.0.1)
+      activesupport (~> 3.0.0)
+    builder (2.1.2)
+    erubis (2.6.6)
+      abstract (>= 1.0.0)
+    haml (3.0.15)
+    i18n (0.4.1)
+    mail (2.2.5)
+      activesupport (>= 2.3.6)
+      mime-types
+      treetop (>= 1.4.5)
+    mime-types (1.16)
+    polyglot (0.3.1)
+    rack (1.2.1)
+    rack-mount (0.6.13)
+      rack (>= 1.0.0)
+    rack-test (0.5.4)
+      rack (>= 1.0)
+    rails (3.0.0)
+      actionmailer (= 3.0.0)
+      actionpack (= 3.0.0)
+      activerecord (= 3.0.0)
+      activeresource (= 3.0.0)
+      activesupport (= 3.0.0)
+      bundler (~> 1.0.0)
+      railties (= 3.0.0)
+    railties (3.0.0)
+      actionpack (= 3.0.0)
+      activesupport (= 3.0.0)
+      rake (>= 0.8.4)
+      thor (~> 0.14.0)
+    rake (0.8.7)
+    shoulda (2.11.3)
+    sqlite3-ruby (1.2.5)
+    thor (0.14.0)
+    treetop (1.4.8)
+      polyglot (>= 0.3.1)
+    tzinfo (0.3.23)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  haml
+  rails
+  shoulda
+  sqlite3-ruby (= 1.2.5)

data/README.rdoc

@@ -8,7 +8,9 @@ Say you're writing a Rails online shop - the shopping cart is reappearing again
 
 No. That sucks. Take Cells.
 
-Cells are View Components for Rails. They look and feel like controllers. They don't have no +DoubleRenderError+. They are callable everywhere in your controllers or views. They are cacheable, testable, fast and wonderful. They bring back OOP to your view and improve your software design.
+Cells are View Components for Rails. They look and feel like controllers. They don't have no +DoubleRenderError+. They can be rendered everywhere in your controllers or views. They are cacheable, testable, fast and wonderful. They bring back OOP to your view and improve your software design.
+
+And the best: You can have as many cells in your page as you need!
 
 == Installation
 
@@ -16,11 +18,11 @@ It's a gem!
 
 Rails 3:
 
-  gem install cells
+  gem install cells --pre
 
 Rails 2.3:
 
-  gem install cells --version 3.3.4
+  gem install cells
 
 
 == Generate
@@ -51,7 +53,8 @@ Time to improve our cell code. Let's start with <tt>app/cells/shopping_cart_cell
 
   class ShoppingCartCell < Cell::Rails 
     def display 
-      @items = @opts[:user].items_in_cart
+      user    = @opts[:user]        # @opts exposes options passed to #render_cell.
+      @items  = user.items_in_cart
       
       render  # renders display.html.erb
     end
@@ -118,7 +121,8 @@ That's easy, clean and strongly improves your component-driven software quality.
 == More features
 
 Cells can do more.
-  
+
+<b>No Limits</b>::  Have as many cells in your page as you need - no limitation to your +render_cell+ calls.
 <b>View Inheritance</b>::  Inherit view files dynamically from parent cells.
 <b>Cell Nesting</b>:: Have complex cell hierarchies as you can call +render_cell+ within cells, too. 
 

data/lib/cell/caching.rb

@@ -1,25 +1,10 @@
-# encoding: utf-8
-
-# To improve performance rendered state views can be cached using Rails' caching
-# mechanism.
-# If this it configured (e.g. using our fast friend memcached) all you have to do is to
-# tell Cells which state to cache. You can further attach a proc to expire the
-# cached view.
-#
-# As always I stole a lot of code, this time from Lance Ivy <cainlevy@gmail.com> and
-# his fine components plugin at http://github.com/cainlevy/components.
+require 'active_support/concern'
+require 'active_support/cache'
 
 module Cell
   module Caching
-
-    def self.included(base) #:nodoc:
-      base.class_eval do
-        extend ClassMethods
-
-        alias_method_chain :render_state, :caching
-      end
-    end
-
+    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.
@@ -106,32 +91,17 @@ module Cell
       end
     end
 
-    def render_state_with_caching(state, request=ActionDispatch::Request.new({}))
-      return render_state_without_caching(state, request) unless state_cached?(state)
-
-      key = cache_key(state, call_version_proc_for_state(state))
-      ### DISCUSS: see sweep discussion at #cache.
+    def render_state(state)
+      return super(state) unless state_cached?(state)
 
-      # cache hit:
-      if content = read_fragment(key)
-        return content
-      end
-      # re-render:
-      return write_fragment(key, render_state_without_caching(state, request), self.class.cache_options[state])
-    end
-
-    def read_fragment(key, cache_options = nil) #:nodoc:
-      returning self.class.cache_store.read(key, cache_options) do |content|
-        log "Cell Cache hit: #{key}" unless content.blank?
+      key     = cache_key(state, call_version_proc_for_state(state))
+      options = self.class.cache_options[state]
+      
+      self.class.cache_store.fetch(key, options) do
+        super(state)
       end
     end
 
-    def write_fragment(key, content, cache_opts = nil) #:nodoc:
-      log "Cell Cache miss: #{key}"
-      self.class.cache_store.write(key, content, cache_opts)
-      content
-    end
-
     # Call the versioning Proc for the respective state.
     def call_version_proc_for_state(state)
       version_proc = self.class.version_procs[state]

data/lib/cell/rails.rb

@@ -7,6 +7,30 @@ module Cell
     include AbstractController
     include Rendering, Layouts, Helpers, Callbacks, Translation
     include ActionController::RequestForgeryProtection
+    
+    module Rendering
+      def render_state(state)
+        rack_response = dispatch(state, parent_controller.request)
+        
+        str = ''      # copied from Response#body.
+        rack_response[2].each { |part| str << part.to_s }
+        str.html_safe # in fact, i'd love to return a real OutputBuffer here.
+      end
+    end
+    
+    class View < ActionView::Base
+      def render(options = {}, locals = {}, &block)
+        if options[:state] or options[:view]
+          return @_controller.render(options, &block)
+        end
+        
+        super
+      end
+    end
+    
+    include Rendering
+    include Caching
+    
     #include AbstractController::Logger
     
     
@@ -25,34 +49,13 @@ module Cell
     
     def log(*args); end
     
-    class View < ActionView::Base
-      def render(options = {}, locals = {}, &block)
-        if options[:state] or options[:view]
-          return @_controller.render(options, &block)
-        end
-        
-        super
-      end
-    end
     
     def self.view_context_class
       controller = self
-        # Unfortunately, there is currently an abstraction leak between AC::Base
-        # and AV::Base which requires having the URL helpers in both AC and AV.
-        # To do this safely at runtime for tests, we need to bump up the helper serial
-        # to that the old AV subclass isn't cached.
-        #
-        # TODO: Make this unnecessary
-        #if @controller
-        #  @controller.singleton_class.send(:include, _routes.url_helpers)
-        #  @controller.view_context_class = Class.new(@controller.view_context_class) do
-        #    include _routes.url_helpers
       
       View.class_eval do
-        
         include controller._helpers
-        
-        include Cell::Base.url_helpers if Cell::Rails.respond_to?(:url_helpers) and Cell::Rails.url_helpers
+        include Cell::Base.url_helpers if Cell::Rails.url_helpers
       end
       
       
@@ -65,26 +68,13 @@ module Cell
     end
     
     def process(*)  # defined in AC::Metal.
-      self.response_body = super  ### TODO: discuss with yehuda.
+      self.response_body = super
     end
-
-    #attr_internal :request
+    
     delegate :request, :to => :parent_controller
     delegate :config, :to => :parent_controller # DISCUSS: what if a cell has its own config (eg for assets, cells/bassist/images)?
     # DISCUSS: let @controller point to @parent_controller in views, and @cell is the actual real controller?
 
-
-    def render_state(state, request=ActionDispatch::Request.new({}))  ### FIXME: where to set Request if none given? leave blank?
-      rack_response = dispatch(state, parent_controller.request)
-      
-      return rack_response[2].last if rack_response[2].kind_of?(Array)  ### FIXME: HACK for testing, wtf is going on here?
-      rack_response[2]  ### TODO: discuss with yehuda.
-      # rack_response in test mode: [nil, nil, ["Doo"]]
-      # rack_response in dev mode:  [nil, nil, "<div>..."]
-    end
-    include Cell::Caching
-
-
     
     
     class << self
@@ -138,6 +128,7 @@ module Cell
       #
       #
       # ==== Where have all the partials gone?
+      #
       # 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 small
       # part of the page.
@@ -148,16 +139,11 @@ module Cell
 
       
 
-      # Climbs up the inheritance hierarchy of the Cell, looking for a view
-      # for the current <tt>state</tt> in each level.
-      # As soon as a view file is found it is returned as an ActionView::Template
-      # instance.
-      ### DISCUSS: moved to Cell::View#find_template in rainhead's fork:
+      # Climbs up the inheritance hierarchy of the Cell, looking for a view for the current +state+ in each level.
       def find_family_view_for_state(state)
         missing_template_exception = nil
 
         possible_paths_for_state(state).each do |template_path|
-          # we need to catch MissingTemplate, since we want to try for all possible family views.
           begin
             template = find_template(template_path)
             return template if template
@@ -167,22 +153,6 @@ module Cell
         
         raise missing_template_exception
       end
-
-      # In production mode, the view for a state/template_format is cached.
-      ### DISCUSS: ActionView::Base already caches results for #pick_template, so maybe
-      ### we should just cache the family path for a state/format?
-      def find_family_view_for_state_with_caching(state)
-        return find_family_view_for_state(state) unless self.class.cache_configured?
-
-        # in production mode:
-        key         = "#{state}/#{action_view.template_format}"
-        state2view  = self.class.state2view_cache
-        state2view[key] || state2view[key] = find_family_view_for_state(state, action_view)
-      end
-
-      
-
-
       
       # Render the view belonging to the given state. Will raise ActionView::MissingTemplate
       # if it can not find one of the requested view template. Note that this behaviour was
@@ -200,9 +170,6 @@ module Cell
           # handle :layout, :template_format, :view
           opts = defaultize_render_options_for(opts, state)
 
-          # set instance vars, include helpers:
-          #prepare_action_view_for(action_view, opts)
-
           #template    = find_family_view_for_state_with_caching(opts[:view], action_view)
           template    = find_family_view_for_state(opts[:view])
           opts[:template] = template
@@ -219,19 +186,7 @@ module Cell
         opts[:view]             ||= state
         opts
       end
-
-      def prepare_action_view_for(action_view, opts)
-        # make helpers available:
-        include_helpers_in_class(action_view.class)
-        
-        import_active_helpers_into(action_view) # in Cells::Cell::ActiveHelper.
-
-        action_view.assigns         = assigns_for_view  # make instance vars available.
-        action_view.template_format = opts[:template_format]
-      end
-
-      # Prepares <tt>opts</tt> to be passed to ActionView::Base#render by removing
-      # unknown parameters.
+      
       def sanitize_render_options(opts)
         opts.except!(:view, :state)
       end

data/lib/cells.rb

@@ -1,25 +1,8 @@
 # encoding: utf-8
 
-begin
-  require 'active_support'
-rescue
-  gem 'activesupport'
-  require 'active_support'
-end
+require 'active_support'
+require 'action_controller'
 
-begin
-  require 'action_controller'
-rescue
-  gem 'actionpack'
-  require 'action_controller'
-end
-
-begin
-  require 'action_view'
-rescue
-  gem 'actionpack'
-  require 'action_view'
-end
 
 require 'cell/base_methods'
 
@@ -72,8 +55,6 @@ Cell::Base = Cell::Rails
 
 Cell::Base.view_paths = Cells::DEFAULT_VIEW_PATHS if Cell::Base.view_paths.blank?
 
-require 'cells/rails'
-
 
 require "rails/railtie"
 class Cells::Railtie < Rails::Railtie
@@ -87,5 +68,6 @@ class Cells::Railtie < Rails::Railtie
   
   initializer "cells.add_load_path" do |app|
     #ActiveSupport::Dependencies.load_paths << Rails.root.join(*%w[app cells])
+    ### DISCUSS: how are cell classes found by Rails?
   end
 end

data/lib/cells/version.rb

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

data/test/abstract_unit.rb

@@ -0,0 +1,248 @@
+### TODO: extract that file to railties/lib/test/isolation/abstract_unit
+
+# Note:
+# It is important to keep this file as light as possible
+# the goal for tests that require this is to test booting up
+# rails from an empty state, so anything added here could
+# hide potential failures
+#
+# It is also good to know what is the bare minimum to get
+# Rails booted up.
+require 'fileutils'
+
+# TODO: Remove rubygems when possible
+require 'rubygems'
+require 'test/unit'
+
+# TODO: Remove setting this magic constant
+#RAILS_FRAMEWORK_ROOT = File.expand_path("#{File.dirname(__FILE__)}/../../..")
+RAILS_FRAMEWORK_ROOT = "/home/nick/projects/rails"
+
+# These files do not require any others and are needed
+# to run the tests
+require "active_support/testing/isolation"
+require "active_support/testing/declarative"
+
+module TestHelpers
+  module Paths
+    module_function
+
+    TMP_PATH = File.expand_path(File.join(File.dirname(__FILE__), *%w[.. .. tmp]))
+
+    def tmp_path(*args)
+      File.join(TMP_PATH, *args)
+    end
+
+    def app_path(*args)
+      tmp_path(*%w[app] + args)
+    end
+
+    def framework_path
+      RAILS_FRAMEWORK_ROOT
+    end
+
+    def rails_root
+      app_path
+    end
+  end
+
+  module Rack
+    def extract_body(response)
+      "".tap do |body|
+        response[2].each {|chunk| body << chunk }
+      end
+    end
+
+    def get(path)
+      @app.call(::Rack::MockRequest.env_for(path))
+    end
+
+    def assert_welcome(resp)
+      assert_equal 200, resp[0]
+      assert resp[1]["Content-Type"] = "text/html"
+      assert extract_body(resp).match(/Welcome aboard/)
+    end
+
+    def assert_success(resp)
+      assert_equal 202, resp[0]
+    end
+
+    def assert_missing(resp)
+      assert_equal 404, resp[0]
+    end
+
+    def assert_header(key, value, resp)
+      assert_equal value, resp[1][key.to_s]
+    end
+
+    def assert_body(expected, resp)
+      assert_equal expected, extract_body(resp)
+    end
+  end
+
+  module Generation
+    def build_app(options = {})
+      FileUtils.rm_rf(app_path)
+      FileUtils.cp_r(tmp_path('app_template'), app_path)
+
+      # Delete the initializers unless requested
+      unless options[:initializers]
+        Dir["#{app_path}/config/initializers/*.rb"].each do |initializer|
+          File.delete(initializer)
+        end
+      end
+
+      unless options[:gemfile]
+        File.delete"#{app_path}/Gemfile"
+      end
+
+      routes = File.read("#{app_path}/config/routes.rb")
+      if routes =~ /(\n\s*end\s*)\Z/
+        File.open("#{app_path}/config/routes.rb", 'w') do |f|
+          f.puts $` + "\nmatch ':controller(/:action(/:id))(.:format)'\n" + $1
+        end
+      end
+
+      add_to_config 'config.secret_token = "3b7cd727ee24e8444053437c36cc66c4"; config.session_store :cookie_store, :key => "_myapp_session"; config.active_support.deprecation = :log'
+    end
+
+    def make_basic_app
+      require "rails"
+      require "action_controller/railtie"
+
+      app = Class.new(Rails::Application)
+      app.config.secret_token = "3b7cd727ee24e8444053437c36cc66c4"
+      app.config.session_store :cookie_store, :key => "_myapp_session"
+      app.config.active_support.deprecation = :log
+
+      yield app if block_given?
+      app.initialize!
+
+      app.routes.draw do
+        match "/" => "omg#index"
+      end
+
+      require 'rack/test'
+      extend ::Rack::Test::Methods
+    end
+
+    class Bukkit
+      attr_reader :path
+
+      def initialize(path)
+        @path = path
+      end
+
+      def write(file, string)
+        path = "#{@path}/#{file}"
+        FileUtils.mkdir_p(File.dirname(path))
+        File.open(path, "w") {|f| f.puts string }
+      end
+
+      def delete(file)
+        File.delete("#{@path}/#{file}")
+      end
+    end
+
+    def plugin(name, string = "")
+      dir = "#{app_path}/vendor/plugins/#{name}"
+      FileUtils.mkdir_p(dir)
+
+      File.open("#{dir}/init.rb", 'w') do |f|
+        f.puts "::#{name.upcase} = 'loaded'"
+        f.puts string
+      end
+
+      Bukkit.new(dir).tap do |bukkit|
+        yield bukkit if block_given?
+      end
+    end
+
+    def engine(name)
+      dir = "#{app_path}/random/#{name}"
+      FileUtils.mkdir_p(dir)
+
+      app = File.readlines("#{app_path}/config/application.rb")
+      app.insert(2, "$:.unshift(\"#{dir}/lib\")")
+      app.insert(3, "require #{name.inspect}")
+
+      File.open("#{app_path}/config/application.rb", 'r+') do |f|
+        f.puts app
+      end
+
+      Bukkit.new(dir).tap do |bukkit|
+        yield bukkit if block_given?
+      end
+    end
+
+    def script(script)
+      Dir.chdir(app_path) do
+        `#{Gem.ruby} #{app_path}/script/rails #{script}`
+      end
+    end
+
+    def add_to_config(str)
+      environment = File.read("#{app_path}/config/application.rb")
+      if environment =~ /(\n\s*end\s*end\s*)\Z/
+        File.open("#{app_path}/config/application.rb", 'w') do |f|
+          f.puts $` + "\n#{str}\n" + $1
+        end
+      end
+    end
+
+    def app_file(path, contents)
+      FileUtils.mkdir_p File.dirname("#{app_path}/#{path}")
+      File.open("#{app_path}/#{path}", 'w') do |f|
+        f.puts contents
+      end
+    end
+
+    def controller(name, contents)
+      app_file("app/controllers/#{name}_controller.rb", contents)
+    end
+
+    def use_frameworks(arr)
+      to_remove =  [:actionmailer,
+                    :activemodel,
+                    :activerecord,
+                    :activeresource] - arr
+      $:.reject! {|path| path =~ %r'/(#{to_remove.join('|')})/' }
+    end
+
+    def boot_rails
+      require File.expand_path('/home/nick/projects/rails/load_paths', __FILE__)
+    end
+  end
+end
+
+class Test::Unit::TestCase
+  include TestHelpers::Paths
+  include TestHelpers::Rack
+  include TestHelpers::Generation
+  extend  ActiveSupport::Testing::Declarative
+end
+
+# Create a scope and build a fixture rails app
+Module.new do
+  extend TestHelpers::Paths
+  # Build a rails app
+  if File.exist?(tmp_path)
+    FileUtils.rm_rf(tmp_path)
+  end
+  FileUtils.mkdir(tmp_path)
+
+  environment = File.expand_path('../../../../load_paths', __FILE__)
+  if File.exist?("#{environment}.rb")
+    require_environment = "-r #{environment}"
+  end
+
+  `#{Gem.ruby} #{require_environment} #{RAILS_FRAMEWORK_ROOT}/bin/rails new #{tmp_path('app_template')}`
+  File.open("#{tmp_path}/app_template/config/boot.rb", 'w') do |f|
+    if require_environment
+      f.puts "Dir.chdir('#{File.dirname(environment)}') do"
+      f.puts "  require '#{environment}'"
+      f.puts "end"
+    end
+    f.puts "require 'rails/all'"
+  end
+end

data/test/active_helper_test.rb

@@ -5,8 +5,6 @@ require File.join(File.dirname(__FILE__), 'test_helper')
 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
@@ -16,17 +14,17 @@ class ActiveHelperTest < ActiveSupport::TestCase
       end
     end
     
-    should "respond to active_helper" do
+    should_eventually "respond to active_helper" do
       assert_respond_to Cell::Base, :active_helper
     end
     
-    should "store helper constants from active_helper" do
+    should_eventually "store helper constants from active_helper" do
       @cell = Class.new(BassistCell)
       @cell.active_helper SlappingHelper
       assert_equal [SlappingHelper], @cell.active_helpers
     end
     
-    should "inherit helper constants from active_helper" do
+    should_eventually "inherit helper constants from active_helper" do
       @base_cell = Class.new(BassistCell)
       @base_cell.active_helper SlappingHelper
       @cell = Class.new(@base_cell)
@@ -45,7 +43,7 @@ class ActiveHelperTest < ActiveSupport::TestCase
     end
     
     context "The view rendered by the cell" do
-      should "respond to used helper methods" do
+      should_eventually "respond to used helper methods" do
         @cell = bassist_mock
         @cell.class.active_helper SlappingHelper
         
@@ -56,5 +54,4 @@ class ActiveHelperTest < ActiveSupport::TestCase
       end
     end
   end
-  
 end

data/test/app/controllers/musician_controller.rb

@@ -1,16 +1,17 @@
 class MusicianController < ActionController::Base
   def promotion
-    render :text => render_cell(:bassist, :play)
+    render :text => render_cell(:bassist, :provoke)
   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 hamlet
+  end
 
   def action_method?(name); true; end ### FIXME: fixes NameError: undefined local variable or method `_router' for MusicianController:Class
 end

data/test/cell_generator_test.rb

@@ -3,7 +3,9 @@ require File.join(File.dirname(__FILE__), *%w[test_helper])
 #require 'rails/generators/test_unit'
 
 
-require '/home/nick/projects/rails/railties/lib/rails/test/isolation/abstract_unit'
+#require '/home/nick/projects/rails/railties/lib/rails/test/isolation/abstract_unit'
+require 'abstract_unit'
+
 #require '/home/nick/projects/rails/railties/test/generators/generators_test_helper'
 require 'rails/generators'
 require 'rails_generators/cell/cell_generator'

data/test/rails/caching_test.rb

@@ -3,19 +3,45 @@ require File.join(File.dirname(__FILE__), '..', 'test_helper')
 
 class DirectorCell < Cell::Rails
   cache :count
+  
   @@counter = 0
+  cattr_accessor :counter
   
-  def count
+  def self.increment!
     @@counter += 1
-    render :text => @@counter
+  end
+  
+  def self.reset!
+    @@counter = 0
+  end
+  
+  def increment!
+    self.class.increment!
+  end
+  
+  def count
+    render :text => increment!
   end 
 end
 
 class CachingTest < ActiveSupport::TestCase
+  context "The DirectorCell" do
+    setup do
+      DirectorCell.reset!
+    end
+    
+    should "respond to #increment" do
+      assert_equal 0, DirectorCell.counter
+      assert_equal 1, DirectorCell.increment!
+      assert_equal 1, DirectorCell.counter
+    end
+  end
+  
   context "A cell" do
     setup do
       ::ActionController::Base.cache_store = :memory_store
       ::ActionController::Base.perform_caching = true
+      DirectorCell.reset!
     end
     
     should "respond to state_cached?" do
@@ -54,12 +80,7 @@ class CachingTest < ActiveSupport::TestCase
     
     context "caching without options" do
       setup do
-        DirectorCell.class_eval do
-          @@counter = 0
-          cattr_accessor :count
-        end
-        
-                key = cell(:director).cache_key(:count, :count => 0)
+        key = cell(:director).cache_key(:count, :count => 0)
         Cell::Base.expire_cache_key(key)  ### TODO: separate test
       end
       
@@ -78,8 +99,7 @@ class CachingTest < ActiveSupport::TestCase
       should "not cache at all" do
         DirectorCell.class_eval do
           def dictate
-            @@counter += 1
-            render :text => @@counter
+            render :text => increment!
           end
         end
         
@@ -90,20 +110,19 @@ class CachingTest < ActiveSupport::TestCase
       should "expire the cache with a version proc" do
         DirectorCell.class_eval do
           cache :count, Proc.new { |cell|
-            cell.class.count >= 2 ? {:count => 2} : {:count => 0}
+            cell.class.counter >= 2 ? {:count => 2} : {:count => 0}
           }
           
           def count
-            render :text => @@count += 1
-            #@@count
+            render :text => increment!
           end 
         end
-        DirectorCell.count = 0
+        DirectorCell.reset!
         
         assert_equal "1", render_cell(:director, :count)
         assert_equal "1", render_cell(:director, :count)  # cached.
         
-        DirectorCell.count = 2  # invalidates the view cache.
+        DirectorCell.counter = 2  # invalidates the view cache.
         assert_equal "3", render_cell(:director, :count)
         assert_equal "3", render_cell(:director, :count)  # cached.
       end
@@ -113,20 +132,19 @@ class CachingTest < ActiveSupport::TestCase
           cache :count, :expire_count
           
           def expire_count
-            self.class.count >= 2 ? {:count => 2} : {:count => 0}
+            self.class.counter >= 2 ? {:count => 2} : {:count => 0}
           end
           
           def count
-            @@count += 1
-            render :text => @@count
+            render :text => increment!
           end 
         end
-        DirectorCell.count = 0
+        DirectorCell.reset!
         
         assert_equal "1", render_cell(:director, :count)
         assert_equal "1", render_cell(:director, :count)  # cached.
         
-        DirectorCell.count = 2  # invalidates the view cache.
+        DirectorCell.counter = 2  # invalidates the view cache.
         assert_equal "3", render_cell(:director, :count)
         assert_equal "3", render_cell(:director, :count)  # cached.
       end
@@ -153,10 +171,10 @@ class CachingTest < ActiveSupport::TestCase
       DirectorCell.class_eval do
         cache :count
         def count
-          render :text => @@count += 1
+          render :text => increment!
         end
       end
-      DirectorCell.count = 0
+      DirectorCell.reset!
       
       @key = cell(:director).cache_key(:count)
       render_cell(:director, :count)
@@ -176,40 +194,9 @@ class CachingTest < ActiveSupport::TestCase
     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)
     end
   end
-
-  def test_find_family_view_for_state_with_caching
-    # test environment: --------------------------------------
-    BassistCell.instance_variable_set :@state2view_cache, {}
-    assert_equal({}, BassistCell.state2view_cache)
-    
-    BassistCell.instance_eval do
-      self.default_template_format = :html
-      
-      def play; render; end
-    end
-    
-    
-    cell = cell(:bassist)
-    cell.class.instance_eval do
-      def cache_configured?; false; end
-    end
-    cell.render_state :play
-    # in development/test environment, no view name caching should happen,
-    # if perform_caching is false.
-    assert_equal({}, BassistCell.state2view_cache)
-
-    # production environment: --------------------------------
-    cell = BassistCell.new(@controller)
-    cell.class.instance_eval do
-      def cache_configured?; true; end
-    end
-    
-    cell.render_state :play
-    assert BassistCell.state2view_cache["play/html"] 
-  end
 end

data/test/rails/cells_test.rb

@@ -30,14 +30,14 @@ class RailsCellsTest < ActiveSupport::TestCase
     end
     
     context "invoking find_family_view_for_state" do
-      should "### use find_template" do
-        assert cell(:bassist).find_template("bassist/play")
+      should "raise an error when a template is missing" do
         assert_raises ActionView::MissingTemplate do
           cell(:bassist).find_template("bassist/playyy")
         end
+        
+        puts "format: #{cell(:bassist).find_template("bassist/play.js").formats.inspect}"
       end
       
-      
       should "return play.html.erb" do
         assert_equal "bassist/play", cell(:bassist).find_family_view_for_state(:play).virtual_path
       end

data/test/rails/integration_test.rb

@@ -1,26 +1,38 @@
 require File.join(File.dirname(__FILE__), '/../test_helper')
 
-require 'active_support/core_ext/object/to_query'
-
 class RailsIntegrationTest < ActionController::TestCase
   
   context "A Rails controller" do
+    
     setup do
       @routes = ActionDispatch::Routing::RouteSet.new
       @routes.draw do
         |map| match ':action', :to => MusicianController
       end
+      
       @controller = MusicianController.new
+      @controller.view_paths << File.expand_path(File.join(File.dirname(__FILE__), '../app/views'))
     end
     
     should "respond to render_cell" do
       get 'promotion'
-      assert_equal "Doo", @response.body
+      assert_equal "That's me, naked <img alt=\"Me\" src=\"/images/me.png\" />", @response.body
     end
     
-    should "respond to render_cell in the view" do
+    should "respond to render_cell in the view without escaping twice" do
+      BassistCell.class_eval do
+        def provoke; render; end
+      end
       get 'featured'
-      assert_equal "Doo", @response.body
+      assert_equal "That's me, naked <img alt=\"Me\" src=\"/images/me.png\" />", @response.body
+    end
+    
+    should "respond to render_cell in a haml view" do
+      BassistCell.class_eval do
+        def provoke; render; end
+      end
+      get 'hamlet'
+      assert_equal "That's me, naked <img alt=\"Me\" src=\"/images/me.png\" />\n", @response.body
     end
     
     should "make params (and friends) available in a cell" do

data/test/rails/router_test.rb

@@ -1,5 +1,5 @@
-require '/home/nick/projects/rails/railties/lib/rails/test/isolation/abstract_unit'
-#require 'rails/test/isolation/abstract_unit'
+#require '/home/nick/projects/rails/railties/lib/rails/test/isolation/abstract_unit'
+require 'abstract_unit'
 
 module ApplicationTests
   class RouterTest < ActionController::TestCase#Test::Unit::TestCase
@@ -44,7 +44,7 @@ module ApplicationTests
           def promote; render; end
         end
       
-        assert ::Cell::Rails.view_context_class._routes, "Cells::Railtie initializer wasn't invoked."
+        #assert ::Cell::Rails.view_context_class._routes, "Cells::Railtie initializer wasn't invoked."
         #assert ! ::OmgController.new.respond_to?( :render_cell)
         
         get "/cell"

data/test/test_helper.rb

@@ -22,17 +22,11 @@ Cell::Rails.append_view_path(File.join(test_app_dir, 'cells'))
 Cell::Rails.append_view_path(File.join(test_app_dir, 'cells', 'layouts'))
 
 
-# Now, load the rest.
+# Now, load the controllers.
 require File.join(test_app_dir, 'controllers', 'cells_test_controller')
 require File.join(test_app_dir, 'controllers', 'musician_controller')
 
-# We need to setup a fake route for the controller tests.
-#ActionController::Routing::Routes.draw do |map|
-#  map.connect 'cells_test/:action', :controller => 'cells_test'
-#end
-#ActionController::Routing::Routes.draw do |map|
-#  map.connect 'musician/:action', :controller => 'musician'
-#end
+
 
 Dir[File.join(gem_dir, 'test', 'support', '**', '*.rb')].each { |f| require f }
 require File.join(gem_dir, 'lib', 'cells', 'assertions_helper')
@@ -49,4 +43,7 @@ class Cell::Rails
 end
 
 require File.join(test_app_dir, 'cells', 'bassist_cell')
-require File.join(test_app_dir, 'cells', 'bad_guitarist_cell')
+require File.join(test_app_dir, 'cells', 'bad_guitarist_cell')
+
+require "haml"
+require "haml/template" # Thanks, Nathan!

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification 
 name: cells
 version: !ruby/object:Gem::Version 
-  hash: 350106850
+  hash: -415343653
   prerelease: true
   segments: 
   - 3
   - 4
   - 0
-  - beta1
-  version: 3.4.0.beta1
+  - beta2
+  version: 3.4.0.beta2
 platform: ruby
 authors: 
 - Nick Sutterer
@@ -16,7 +16,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2010-07-23 00:00:00 +02:00
+date: 2010-09-09 00:00:00 +02:00
 default_executable: 
 dependencies: []
 
@@ -31,6 +31,7 @@ extra_rdoc_files:
 files: 
 - CHANGES
 - Gemfile
+- Gemfile.lock
 - MIT-LICENSE
 - README.rdoc
 - Rakefile
@@ -57,6 +58,7 @@ files:
 - rails_generators/erb/cell_generator.rb
 - rails_generators/erb/templates/view.html.erb
 - test/active_helper_test.rb
+- test/abstract_unit.rb
 - test/base_methods_test.rb
 - test/assertions_helper_test.rb
 - test/rails/router_test.rb
@@ -115,6 +117,7 @@ specification_version: 3
 summary: Cells are lightweight controllers for Rails and can be rendered in controllers and views, providing an elegant and fast way for encapsulation and component-orientation.
 test_files: 
 - test/active_helper_test.rb
+- test/abstract_unit.rb
 - test/base_methods_test.rb
 - test/assertions_helper_test.rb
 - test/rails/router_test.rb