cells 3.6.7 → 3.7.0

data/CHANGES.textile

@@ -1,3 +1,17 @@
+h2. 3.7.0
+
+h3. Changes
+  * Cache settings using @Base.cache@ are now inherited.
+  * Removed <code>@opts</code>.
+  * Removed @#options@ in favor of state-args. If you still want the old behaviour, include the @Deprecations@ module in your cell.
+  * The build process is now instantly delegated to Base.build_for on the concrete cell class.
+
+h2. 3.6.8
+
+h3. Changes
+  * Removed <code>@opts</code>.
+  * Deprecated @#options@ in favour of state-args. 
+
 h2. 3.6.7
 
 h3. Changes

data/README.rdoc

@@ -24,7 +24,7 @@ Rails 3.x:
 
 Rails 2.3:
 
-  gem install cells -v 3.3.8
+  gem install cells -v 3.3.9
 
 
 == Generate

data/lib/cell.rb

@@ -3,28 +3,31 @@ module Cell
 
   extend ActiveSupport::Concern
   
-  DEFAULT_VIEW_PATHS = [
-    File.join('app', 'cells'),
-  ]
-    
+  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) # DISCUSS: pass args here?
-      yield cell if block_given?  # DISCUSS: call block before or after render?
+      cell = create_cell_for(controller, name, *args)
+      yield cell if block_given?
       
-      cell.render_state_with_args(state, *args)
+      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)
-      build_class_for(controller, class_from_cell_name(name), *args).
-      new(controller, *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
@@ -57,31 +60,21 @@ module Cell
       builders << block
     end
     
-    def build_class_for(controller, target_class, *args)
-      target_class.builders.each do |blk|
-        res = controller.instance_exec(*args, &blk) and return res
-      end
-      target_class
-    end
-    
-    def builders
-      @builders ||= []
-    end
-
     # The cell class constant for +cell_name+.
     def class_from_cell_name(cell_name)
       "#{cell_name}_cell".classify.constantize
     end
-  end
-
-  module InstanceMethods
-    def render_state_with_args(state, *args)  # TODO: remove me in 4.0.
-      return render_state(state, *args) if state_accepts_args?(state)
-      render_state(state)  # backward-compat.
+    
+  protected
+    def build_class_for(controller, *args)
+      builders.each do |blk|
+        klass = controller.instance_exec(*args, &blk) and return klass
+      end
+      self
     end
     
-    def state_accepts_args?(state)
-      method(state).arity != 0
+    def builders
+      @builders ||= []
     end
   end
 end

data/lib/cell/caching.rb

@@ -5,6 +5,13 @@ module Cell
   module Caching
     extend ActiveSupport::Concern
 
+    included do
+      class_attribute :version_procs, :conditional_procs, :cache_options
+      self.version_procs = {}
+      self.conditional_procs = {}
+      self.cache_options = {}
+    end
+
     module ClassMethods
       # Caches the rendered view of +state+.
       #
@@ -41,25 +48,16 @@ module Cell
       #
       # Two things to mention here.
       # * The return value of the method/block is <em>appended</em> to the state cache key.
-      # * You may return a string, a hash, an array, ActiveSupport::Caching will compile it. 
+      # * You may return a string, a hash, an array, ActiveSupport::Caching will compile it.
+      #
+      # == Inheritance
+      # Please note that cache configuration is inherited to derived cells.
       def cache(state, *args, &block)
         options = args.extract_options!
-        
-        conditional_procs[state] = options.delete(:if)
-        version_procs[state]     = args.first || block
-        cache_options[state]     = options
-      end
-
-      def version_procs
-        @version_procs ||= {}
-      end
-
-      def conditional_procs
-        @conditional_procs ||= {}
-      end
 
-      def cache_options
-        @cache_options ||= {}
+        self.conditional_procs = conditional_procs.merge(state => options.delete(:if))
+        self.version_procs     = version_procs.merge(state => (args.first || block))
+        self.cache_options     = cache_options.merge(state => options)
       end
 
       def cache_store
@@ -112,7 +110,7 @@ module Cell
   protected
     def call_proc_or_method(state, method, *args)
       return method.call(self, *args) if method.kind_of?(Proc)
-      state_accepts_args?(state) ?  send(method, *args) : send(method)
+      send(method, *args)
     end
     
     def call_state_versioner(state, *args)

data/lib/cell/deprecations.rb

@@ -0,0 +1,42 @@
+module Cell
+  # Makes #options available in Cells 3.7, which was removed in favor of state-args.
+  module Deprecations
+    extend ActiveSupport::Concern
+    
+    included do
+      attr_reader :options
+    end
+    
+    
+    module ClassMethods
+      def build_for(controller, *args)
+        build_class_for(controller, *args).
+        new(controller, *args)
+      end
+    end
+    
+    
+    module InstanceMethods
+      def initialize(parent_controller, *args)
+        super(parent_controller)  # the real Base.new.
+        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
+        @options  = ActiveSupport::Deprecation::DeprecatedObjectProxy.new(@_options, "#options is deprecated and was removed in Cells 3.7. Please use state-args.")
+      end
+      
+      def render_state(state, *args)
+        return super(state, *args) if state_accepts_args?(state)
+        super(state)  # backward-compat.
+      end
+      
+      def state_accepts_args?(state)
+        method(state).arity != 0
+      end
+    end
+    
+  end
+end

data/lib/cell/rails.rb

@@ -42,23 +42,13 @@ module Cell
     include Rendering
     include Caching
     
-    
     attr_reader :parent_controller
-    attr_accessor :options
-    
     abstract!
 
 
-    def initialize(parent_controller, *args)
+    def initialize(parent_controller)
       super()
-      @parent_controller  = parent_controller
-      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)
+      @parent_controller = parent_controller
     end
     
     def self.controller_path

data/lib/cell/test_case.rb

@@ -98,7 +98,7 @@ module Cell
         # DISCUSS: should we allow passing a block here, just as in controllers?
         @subject_cell = ::Cell::Base.create_cell_for(@controller, name, *args)
         @view_assigns = extract_state_ivars_for(@subject_cell) do
-          @last_invoke = @subject_cell.render_state_with_args(state, *args)
+          @last_invoke = @subject_cell.render_state(state, *args)
         end
         
         @last_invoke
@@ -108,10 +108,11 @@ module Cell
       # Passes the optional block to <tt>cell.instance_eval</tt>.
       #
       # Example:
-      #   assert_equal "Banks kill planet!" cell(:news, :topic => :terror).latest_headline
+      #   assert_equal "Doo Dumm Dumm..." cell(:bassist).play
       def cell(name, *args, &block)
         cell = ::Cell::Base.create_cell_for(@controller, name, *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
       end
 
@@ -122,16 +123,16 @@ module Cell
       #
       #   assert_equal("<h1>Modularity rocks.</h1>", in_view do content_tag(:h1, "Modularity rocks."))
       def in_view(cell_class, &block)
-        subject = cell(cell_class, :block => block)
+        subject = cell(cell_class)
         setup_test_states_in(subject) # add #in_view to subject cell.
-        subject.render_state(:in_view)
+        subject.render_state(:in_view, block)
       end
 
     protected
       def setup_test_states_in(cell)
         cell.instance_eval do
-          def in_view
-            render :inline => "<%= instance_exec(&block) %>", :locals => {:block => options[:block]}
+          def in_view(block=nil)
+            render :inline => "<%= instance_exec(&block) %>", :locals => {:block => block}
           end
         end
       end
@@ -147,7 +148,7 @@ module Cell
 
 
     def invoke(state, *args)
-      @last_invoke = self.class.controller_class.new(@controller, *args).render_state_with_args(state, *args)
+      @last_invoke = self.class.controller_class.new(@controller).render_state(state, *args)
     end
   end
 end

data/lib/cells.rb

@@ -84,5 +84,6 @@ 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/version.rb

@@ -1,3 +1,3 @@
 module Cells
-  VERSION = '3.6.7'
+  VERSION = '3.7.0'
 end

data/test/cell_module_test.rb

@@ -1,7 +1,6 @@
 require 'test_helper'
 
 class MusicianCell < Cell::Base
-  
 end
 
 class PianistCell < MusicianCell
@@ -32,24 +31,6 @@ class CellModuleTest < ActiveSupport::TestCase
         assert_equal "Doo", html
         assert flag
       end
-      
-      should "make options available in #options if not receiving state-args" do
-        BassistCell.class_eval do
-          def listen
-            render :text => options[:note]
-          end
-        end
-        assert_equal "C-minor", Cell::Base.render_cell_for(@controller, :bassist, :listen, :note => "C-minor")
-      end
-      
-      should "pass options as state-args and still set #options otherwise" do
-        BassistCell.class_eval do
-          def listen(args)
-            render :text => args[:note] + options[:note].to_s
-          end
-        end
-        assert_equal "C-minorC-minor", Cell::Base.render_cell_for(@controller, :bassist, :listen, :note => "C-minor")
-      end
     end
     
     context "create_cell_for" do
@@ -64,7 +45,7 @@ class CellModuleTest < ActiveSupport::TestCase
       end
     end
     
-    context "calling build" do
+    context "#create_cell_for with #build" do
       setup do
         @controller.class_eval do
           attr_accessor :bassist
@@ -86,13 +67,13 @@ class CellModuleTest < ActiveSupport::TestCase
       
       should "execute the block in controller context" do
         @controller.bassist = true
-        assert_equal BassistCell,  Cell::Base.build_class_for(@controller, MusicianCell, {})
+        assert_is_a BassistCell,  Cell::Base.create_cell_for(@controller, :musician, {})
       end
       
       should "limit the builder to the receiving class" do
-        assert_equal PianistCell,   Cell::Base.build_class_for(@controller, PianistCell, {})   # don't inherit anything.
+        assert_is_a PianistCell,   Cell::Base.create_cell_for(@controller, :pianist, {})   # don't inherit anything.
         @controller.bassist = true
-        assert_equal BassistCell,   Cell::Base.build_class_for(@controller, MusicianCell, {})
+        assert_is_a BassistCell,   Cell::Base.create_cell_for(@controller, :musician, {})
       end
       
       should "chain build blocks and execute them by ORing them in the same order" do
@@ -104,13 +85,13 @@ class CellModuleTest < ActiveSupport::TestCase
           UnknownCell # should never be executed.
         end
         
-        assert_equal PianistCell, Cell::Base.build_class_for(@controller, MusicianCell, {})  # bassist is false.
+        assert_is_a PianistCell, Cell::Base.create_cell_for(@controller, :musician, {})  # bassist is false.
         @controller.bassist = true
-        assert_equal BassistCell, Cell::Base.build_class_for(@controller, MusicianCell, {})
+        assert_is_a BassistCell, Cell::Base.create_cell_for(@controller, :musician, {})
       end
       
       should "use the original cell if no builder matches" do
-        assert_equal MusicianCell, Cell::Base.build_class_for(@controller, MusicianCell, {})  # bassist is false.
+        assert_is_a MusicianCell, Cell::Base.create_cell_for(@controller, :musician, {})  # bassist is false.
       end
       
       should "stop at the first builder returning a valid cell" do
@@ -121,16 +102,16 @@ class CellModuleTest < ActiveSupport::TestCase
         BassistCell.build do |opts|
           SingerCell if opts[:sing_the_song]
         end
-        assert_equal BassistCell, Cell::Base.build_class_for(@controller, BassistCell, {})
-        assert_equal SingerCell,  Cell::Base.build_class_for(@controller, BassistCell, {:sing_the_song => true})
+        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})
       end
       
       should "create the original target class if no block matches" do
-        assert_equal PianistCell, Cell::Base.build_class_for(@controller, PianistCell, {})
+        assert_kind_of PianistCell, Cell::Base.create_cell_for(@controller, :pianist, {})
       end
       
       should "builders should return an empty array per default" do
-        assert_equal [], PianistCell.builders
+        assert_equal [], PianistCell.send(:builders)
       end
     end
     
@@ -154,29 +135,5 @@ class CellModuleTest < ActiveSupport::TestCase
         assert_equal "cell_module_test/singer", CellModuleTest::SingerCell.cell_name
       end
     end
-    
-    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
-      
-      should "be true for multiple arg with defaults" do
-        assert(cell(:bassist) do 
-          def listen(what, where="") end 
-        end.state_accepts_args?(:listen))
-      end
-    end
   end
 end

data/test/deprecations_test.rb

@@ -0,0 +1,95 @@
+require 'test_helper'
+
+class SongwriterCell < BassistCell
+  include Cell::Deprecations
+end
+
+
+class DeprecationsTest < ActiveSupport::TestCase
+  include Cell::TestCase::TestMethods
+  
+  context "#render_state" do
+    should "work without args and provide #options" do
+      SongwriterCell.class_eval do
+        def listen
+          render :text => options[:note]
+        end
+      end
+      assert_equal "D", cell(:songwriter, :note => "D").render_state(:listen)
+    end
+    
+    include ActiveSupport::Testing::Deprecation
+    should "mark @options as deprecated, but still work" do
+      res = nil
+      assert_deprecated do
+        res = cell(:songwriter, :song => "Lockdown").instance_eval do
+          options[:song]
+        end
+      end
+      assert_equal "Lockdown", res
+    end
+  end
+  
+  context "render_cell_for" do
+    should "make options available in #options if not receiving state-args" do
+      SongwriterCell.class_eval do
+        def listen
+          render :text => options[:note]
+        end
+      end
+      assert_equal "C-minor", Cell::Base.render_cell_for(@controller, :songwriter, :listen, :note => "C-minor")
+    end
+      
+    should "pass options as state-args and still set #options otherwise" do
+      SongwriterCell.class_eval do
+        def listen(args)
+          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")
+    end
+  end
+  
+  context "#state_accepts_args?" do
+    should "be false if state doesn't want args" do
+      assert_not cell(:songwriter).state_accepts_args?(:play)
+    end
+    
+    should "be true for one arg" do
+      assert(cell(:songwriter) do 
+        def listen(args) end 
+      end.state_accepts_args?(:listen))
+    end
+    
+    should "be true for multiple arg" do
+      assert(cell(:songwriter) do 
+        def listen(what, where) end 
+      end.state_accepts_args?(:listen))
+    end
+    
+    should "be true for multiple arg with defaults" do
+      assert(cell(:songwriter) do 
+        def listen(what, where="") end 
+      end.state_accepts_args?(:listen))
+    end
+  end
+  
+  context ".cache" do
+    should "still be able to use options in the block" do
+      SongwriterCell.class_eval do
+        def count(args)
+          render :text => args[:int]
+        end
+        
+        cache :count do |cell, i|
+          (cell.options[:int] % 2)==0 ? {:count => "even"} : {:count => "odd"}
+        end
+      end
+      
+      assert_equal "1", render_cell(:songwriter, :count, :int => 1)
+      assert_equal "2", render_cell(:songwriter, :count, :int => 2)
+      assert_equal "1", render_cell(:songwriter, :count, :int => 3)
+      assert_equal "2", render_cell(:songwriter, :count, :int => 4)
+    end
+  end
+end

data/test/rails/caching_test.rb

@@ -128,6 +128,10 @@ class CachingUnitTest < ActiveSupport::TestCase
   context ".cache" do
     setup do
       @proc = Proc.new{}
+
+      @parent = Class.new(@class)
+      @child = Class.new(@parent)
+      @sibbling = Class.new(@parent)
     end
     
     should "accept a state name, only" do
@@ -164,14 +168,34 @@ class CachingUnitTest < ActiveSupport::TestCase
       assert_kind_of Proc, @class.version_procs[:count]
       assert_equal({},    @class.cache_options[:count])
     end
-    
-    should "not inherit caching configuration" do
-      @class.cache :count
-      klass = Class.new(@class)
-      klass.cache :count, @proc
-      
-      assert_not cell(:director).class.version_procs[:count]
-      assert_equal @proc, klass.version_procs[:count]
+
+    should "inherit caching configuration" do
+      @parent.cache :inherited_cache_configuration
+
+      assert @parent.version_procs.has_key?(:inherited_cache_configuration)
+      assert @child.version_procs.has_key?(:inherited_cache_configuration)
+    end
+
+    should "not overwrite caching configuration in the parent class" do
+      @child.cache :inherited_cache_configuration
+
+      assert_not @parent.version_procs.has_key?(:inherited_cache_configuration)
+      assert @child.version_procs.has_key?(:inherited_cache_configuration)
+    end
+
+    should "not overwrite caching configuration in a sibbling class" do
+      @sibbling.cache :inherited_cache_configuration
+
+      assert_not @child.version_procs.has_key?(:inherited_cache_configuration)
+      assert @sibbling.version_procs.has_key?(:inherited_cache_configuration)
+    end
+
+    should "overwrite caching configuration in a child class" do
+      @class.cache :inherited_cache_configuration
+      @child.cache :inherited_cache_configuration, @proc
+
+      assert_not @parent.version_procs[:inherited_cache_configuration]
+      assert_equal @proc, @child.version_procs[:inherited_cache_configuration]
     end
   end
 end
@@ -230,7 +254,7 @@ class CachingFunctionalTest < ActiveSupport::TestCase
       end
     end
     
-    should "compute the key with a block" do
+    should "compute the key with a block receiving state-args" do
       @class.cache :count do |cell, int|
         (int % 2)==0 ? {:count => "even"} : {:count => "odd"}
       end
@@ -242,26 +266,10 @@ 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
+        private
         def version(int)
           (int % 2)==0 ? {:count => "even"} : {:count => "odd"}
         end

data/test/rails/cells_test.rb

@@ -20,10 +20,10 @@ class RailsCellsTest < ActiveSupport::TestCase
     should "work without args" do
       BassistCell.class_eval do
         def listen
-          render :text => options[:note]
+          render :text => "That's a D!"
         end
       end
-      assert_equal "D", cell(:bassist, :note => "D").render_state(:listen)
+      assert_equal "That's a D!", cell(:bassist).render_state(:listen)
     end
     
     should "accept state-args" do
@@ -76,20 +76,6 @@ class RailsCellsTest < ActiveSupport::TestCase
       assert_equal({}, cell(:bassist).config)
     end
     
-    include ActiveSupport::Testing::Deprecation
-    should "mark @opts as deprecated, but still works" do
-      res = nil
-      assert_deprecated do
-        res = cell(:bassist, :song => "Lockdown").instance_eval do
-          @opts[:song]
-        end
-      end
-      assert_equal "Lockdown", res
-    end
-    
-    should "respond to #options and return the cell options" do
-      assert_equal({:song => "Lockdown"}, cell(:bassist, :song => "Lockdown").options)
-    end
     
     if Cells.rails3_0?
       puts "rails-3.0"

data/test/test_case_test.rb

@@ -1,7 +1,8 @@
 require 'test_helper'
 
 class TestCaseTest < Cell::TestCase
-  
+  include ActiveSupport::Testing::Deprecation
+    
   context "A TestCase" do
     setup do
       @test = Cell::TestCase.new(:cell_test)
@@ -19,16 +20,20 @@ class TestCaseTest < Cell::TestCase
       assert_selector "p", "Doo", "<p>Doo</p>y"
     end
     
-    should "respond to #cell" do
-      assert_kind_of BassistCell, cell(:bassist)
-    end
-    
-    should "respond to #cell with a block" do
-      assert_respond_to cell(:bassist){ def whatever; end }, :whatever
-    end
-    
-    should "respond to #cell with options and block" do
-      assert_equal({:topic => :peace}, cell(:bassist, :topic => :peace).options)
+    context "#cell" do
+      should "create a cell" do
+        assert_kind_of BassistCell, cell(:bassist)
+      end
+      
+      should "accept a block" do
+        assert_respond_to cell(:bassist){ def whatever; end }, :whatever
+      end
+      
+      should "mark options as deprecated" do
+        assert_deprecated do
+          res = cell(:bassist, :song => "Lockdown")
+        end
+      end
     end
     
     context "#subject_cell" do
@@ -103,11 +108,11 @@ class TestCaseTest < Cell::TestCase
       
       context "#setup_test_states_in" do
         should "add the :in_view state" do
-          c = cell(:bassist, :block => lambda{"Cells rock."})
+          c = cell(:bassist)
           assert_not c.respond_to?(:in_view)
           
           setup_test_states_in(c)
-          assert_equal "Cells rock.", c.render_state(:in_view)
+          assert_equal "Cells rock.", c.render_state(:in_view, lambda{"Cells rock."})
         end
       end
       

data/test/test_helper.rb

@@ -28,6 +28,10 @@ ActiveSupport::TestCase.class_eval do
   def assert_not(assertion)
     assert !assertion
   end
+  
+  def assert_is_a(klass, object)
+    assert object.is_a?(klass)
+  end
 end
 
 # Enable dynamic states so we can do Cell.class_eval { def ... } at runtime.

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 3
-  - 6
   - 7
-  version: 3.6.7
+  - 0
+  version: 3.7.0
 platform: ruby
 authors: 
 - Nick Sutterer
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-09-28 00:00:00 +02:00
+date: 2011-10-13 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -130,6 +130,7 @@ files:
 - cells.gemspec
 - lib/cell.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
@@ -185,6 +186,7 @@ files:
 - test/cell_generator_test.rb
 - test/cell_module_test.rb
 - test/cells_module_test.rb
+- test/deprecations_test.rb
 - test/dummy/Rakefile
 - test/dummy/app/controllers/application_controller.rb
 - test/dummy/app/controllers/musician_controller.rb