cells 4.0.0.beta4 → 4.0.0.beta5

data/lib/cell/twin.rb

@@ -13,8 +13,8 @@ module Cell
       end
     end
 
-    def initialize(controller, model, options={})
-      super(controller, build_twin(model, options))
+    def initialize(model, options={})
+      super(build_twin(model, options), controller: options.delete(:controller))
     end
   end
 end

data/lib/cell/util.rb

@@ -0,0 +1,16 @@
+module Cell::Util
+  def util
+    Inflector
+  end
+
+  class Inflector
+    # copied from ActiveSupport.
+    def self.underscore(constant)
+      constant.gsub(/::/, '/').
+      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+      gsub(/([a-z\d])([A-Z])/,'\1_\2').
+      tr("-", "_").
+      downcase
+    end
+  end
+end

data/lib/cell/version.rb

@@ -1,10 +1,3 @@
 module Cell
-  module VERSION
-    MAJOR = 4
-    MINOR = 0
-    TINY  = 0
-    PRE   = "beta4"
-
-    STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
-  end
+  VERSION = "4.0.0.beta5"
 end

data/lib/cell/view_model.rb

@@ -1,21 +1,22 @@
-# FIXME: remove AC dependency by delegating forgery
-require 'action_controller'
-
 # no helper_method calls
 # no instance variables
 # no locals
 # options are automatically made instance methods via constructor.
 # call "helpers" in class
 
-# TODO: CACHE prefixes.
-
 # TODO: warn when using ::property but not passing in model in constructor.
 module Cell
-  class ViewModel < AbstractController::Base
+  class ViewModel
+    extend Abstract
     abstract!
 
+    def controller_path
+      self.class.controller_path
+    end
+
     extend Uber::InheritableAttr
     extend Uber::Delegates
+    include Uber::Builder
 
     inheritable_attr :view_paths
     self.view_paths = ["app/cells"]
@@ -32,35 +33,35 @@ module Cell
 
     include Prefixes
     extend SelfContained
-
-    include Uber::Builder
-
+    extend Util
 
     def self.controller_path
-      @controller_path ||= name.sub(/Cell$/, '').underscore
+      @controller_path ||= util.underscore(name.sub(/Cell$/, ''))
     end
 
-    include ActionController::RequestForgeryProtection
-    delegate :session, :params, :request, :config, :env, :url_options, :to => :parent_controller
+    # FIXME: this is all rails-only.
+    # DISCUSS: who actually uses forgery protection with cells? it is not working since 4, anyway?
+    # include ActionController::RequestForgeryProtection
+    delegates :parent_controller, :session, :params, :request, :config, :env, :url_options
 
     attr_reader :model
 
 
     module Helpers
       # Renders collection of cells.
-      def cells_collection(name, controller, array, options)
+      def _collection(name, array, options) # private.
         method = options.delete(:method) || :show
-        join = options.delete(:collection_join)
-        array.collect { |model| cell_for(name, *[controller, model, options]).call(method) }.join(join).html_safe
+        join   = options.delete(:collection_join)
+        array.collect { |model| cell_for(name, *[model, options]).call(method) }.join(join).html_safe
       end
 
       # Returns cell instance.
-      def cell(name, controller, model=nil, options={}, &block) # classic Rails fuzzy API.
+      def cell(name, model=nil, options={}, &block) # classic Rails fuzzy API.
         if model.is_a?(Hash) and array = model.delete(:collection)
-          return cells_collection(name, controller, array, model)
+          return _collection(name, array, model.merge(options))
         end
 
-        cell_for(name, controller, model, options, &block)
+        cell_for(name, model, options, &block)
       end
     end
     extend Helpers
@@ -74,62 +75,72 @@ module Cell
       include Helpers
 
 
-      def cell_for(name, controller, *args)
-        class_from_cell_name(name).build_cell(controller, *args)
+      def cell_for(name, *args)
+        class_from_cell_name(name).build_cell(*args)
       end
 
       def class_from_cell_name(name)
         "#{name}_cell".classify.constantize
       end
 
-      def build_cell(controller, *args)
-        class_builder.call(*args).new(controller, *args) # Uber::Builder::class_builder.
+      def build_cell(*args)
+        class_builder.call(*args).new(*args) # Uber::Builder::class_builder.
       end
     end
 
-    def cell(name, *args)
-      self.class.cell(name, parent_controller, *args)
+    # Get nested cell in instance.
+    def cell(name, model=nil, options={})
+      self.class.cell(name, model, options.merge(controller: parent_controller))
     end
 
 
-    def initialize(controller, model=nil, options={})
-      @parent_controller = controller # TODO: this is removed in 4.0.
+    def initialize(model=nil, options={}) # in Ruby 2: def m(model: nil, controller:nil, **options) that'll make the controller optional.
+      # options            = options.clone # DISCUSS: this could be time consuming when rendering many of em.
+      @parent_controller = options[:controller] # TODO: filter out controller in a performant way.
 
       setup!(model, options)
     end
     attr_reader :parent_controller
     alias_method :controller, :parent_controller
 
+    module Rendering
+      # Invokes the passed method (defaults to :show) while respecting caching.
+      # In Rails, the return value gets marked html_safe.
+      #
+      # Yields +self+ to an optional block.
+      def call(state=:show, *args)
+        content = render_state(state, *args)
+        yield self if block_given?
+
+        content.to_s
+      end
 
-    # render :show
-    def render(options={})
-      options = normalize_options(options, caller) # TODO: call render methods with call(:show), call(:comments) instead of directly #comments?
-      render_to_string(options)
-    end
-
-    def render_to_string(options)
-      template = template_for(options) # TODO: cache template with path/lookup keys.
-      content  = template.render(self, options[:locals])
-
-      # TODO: allow other (global) layout dirs.
-      with_layout(options, content)
-    end
+    private
+      # render :show
+      def render(options={})
+        options = normalize_options(options, caller) # TODO: call render methods with call(:show), call(:comments) instead of directly #comments?
+        render_to_string(options)
+      end
 
+      def render_to_string(options)
+        template = template_for(options) # TODO: cache template with path/lookup keys.
+        content  = template.render(self, options[:locals])
 
-    # Invokes the passed method (defaults to :show). This will respect caching and marks the string as html_safe.
-    #
-    # Please use #call instead of calling methods directly. This allows adding caching later without changing
-    # your code.
-    #
-    # Yields +self+ (the cell instance) to an optional block.
-    def call(state=:show, *args)
-      content = render_state(state, *args)
-      yield self if block_given?
+        # TODO: allow other (global) layout dirs.
+        with_layout(options, content)
+      end
 
-      content.to_s.html_safe
+      def render_state(*args)
+        send(*args)
+      end
     end
 
-    alias_method :to_s, :call
+    include Rendering
+    # alias_method :to_s, :call # FIXME: why doesn't this work?
+    def to_s
+      call
+    end
+    include Caching
 
   private
     attr_reader :options
@@ -140,15 +151,6 @@ module Cell
       # or: create_twin(model, options)
     end
 
-    module Rendering
-      def render_state(*args)
-        send(*args)
-      end
-    end
-    include Rendering
-    include Caching
-
-
     class OutputBuffer < Array
       def encoding
         "UTF-8"
@@ -192,7 +194,8 @@ module Cell
 
     def normalize_options(options, caller) # TODO: rename to #setup_options! to be inline with Trb.
       options = if options.is_a?(Hash)
-        options.reverse_merge(:view => state_for_implicit_render(caller))
+        # TODO: speedup by not doing state_for_implicit_render.
+        {:view => state_for_implicit_render(caller)}.merge(options)
       else
         {:view => options.to_s}
       end
@@ -217,35 +220,5 @@ module Cell
     end
 
     include Layout
-
-
-    if defined?(ActionView)
-      # FIXME: this module is to fix a design flaw in Rails 4.0. the problem is that AV::UrlHelper mixes in the wrong #url_for.
-      # if we could mix in everything else from the helper except for the #url_for, it would be fine.
-      # FIXME: fix that in rails core.
-      if Cell.rails_version <= Gem::Version.new('4.0')
-        include ActionView::Helpers::UrlHelper # gives us breaking #url_for.
-
-        def url_for(options = nil) # from ActionDispatch:R:UrlFor.
-          case options
-            when nil
-              _routes.url_for(url_options.symbolize_keys)
-            when Hash
-              _routes.url_for(options.symbolize_keys.reverse_merge!(url_options))
-            when String
-              options
-            when Array
-              polymorphic_url(options, options.extract_options!)
-            else
-              polymorphic_url(options)
-          end
-        end
-
-        public :url_for
-      else
-        include ActionView::Helpers::UrlHelper
-      end
-      include ActionView::Helpers::FormTagHelper
-    end
   end
 end

data/test/builder_test.rb

@@ -34,25 +34,25 @@ class BuilderTest < MiniTest::Spec
   end
 
   # the original class is used when no builder matches.
-  it { Cell::ViewModel.cell("builder_test/song", nil, Song.new("Nation States"), {}).must_be_instance_of BuilderTest::SongCell }
+  it { Cell::ViewModel.cell("builder_test/song", Song.new("Nation States"), {}).must_be_instance_of BuilderTest::SongCell }
 
   it do
-    cell = Cell::ViewModel.cell("builder_test/song", nil, Hit.new("New York"), {})
+    cell = Cell::ViewModel.cell("builder_test/song", Hit.new("New York"), {})
     cell.must_be_instance_of BuilderTest::HitCell
     cell.options.must_equal({})
   end
 
   it do
-    cell = Cell::ViewModel.cell("builder_test/song", nil, Song.new("San Francisco"), evergreen: true)
+    cell = Cell::ViewModel.cell("builder_test/song", Song.new("San Francisco"), evergreen: true)
     cell.must_be_instance_of BuilderTest::EvergreenCell
     cell.options.must_equal({:evergreen=>true})
   end
 
   # with collection.
-  it { Cell::ViewModel.cell("builder_test/song", nil, collection: [Song.new("Nation States"), Hit.new("New York")]).must_equal "* Nation States* **New York**" }
+  it { Cell::ViewModel.cell("builder_test/song", collection: [Song.new("Nation States"), Hit.new("New York")]).must_equal "* Nation States* **New York**" }
 
   # with Concept
   class Track < Cell::Concept
   end
-  it { Cell::Concept.cell("builder_test/track", nil).must_be_instance_of Track }
+  it { Cell::Concept.cell("builder_test/track").must_be_instance_of Track }
 end

data/test/caching_test.rb

@@ -117,7 +117,7 @@ end
 
 class CachingTest < MiniTest::Spec
   class DirectorCell < Cell::ViewModel
-    def initialize(controller, counter=0)
+    def initialize(counter=0)
       super
       @counter = counter
     end
@@ -141,7 +141,7 @@ class CachingTest < MiniTest::Spec
 
   # let (:cell) { DirectorCell.new(nil) }
   def cellule(*args)
-    DirectorCell.new(nil, *args)
+    DirectorCell.new(*args)
   end
 
   # no caching when turned off.

data/test/cell_test.rb

@@ -9,5 +9,5 @@ class CellTest < MiniTest::Spec
   it { Cell.rails_version.must_equal Gem::Version.new(ActionPack::VERSION::STRING) }
 
   # #options
-  it { SongCell.new(nil, nil, genre: "Punkrock").send(:options)[:genre].must_equal "Punkrock" }
+  it { SongCell.new(nil, genre: "Punkrock").send(:options)[:genre].must_equal "Punkrock" }
 end

data/test/concept_test.rb

@@ -24,6 +24,11 @@ module Record
     class Hit < ::Cell::Concept
       inherit_views Record::Cell
     end
+
+
+    def description
+      "A Tribute To Rancid, with #{@options[:tracks]} songs! [#{parent_controller}]"
+    end
   end
 end
 
@@ -34,27 +39,36 @@ end
 
 class ConceptTest < MiniTest::Spec
   describe "::controller_path" do
-    it { Record::Cell.new(@controller).controller_path.must_equal "record" }
-    it { Record::Cell::Song.new(@controller).controller_path.must_equal "record/song" }
+    it { Record::Cell.new.controller_path.must_equal "record" }
+    it { Record::Cell::Song.new.controller_path.must_equal "record/song" }
   end
 
 
   describe "#_prefixes" do
-    it { Record::Cell.new(@controller)._prefixes.must_equal       ["test/fixtures/concepts/record/views"] }
-    it { Record::Cell::Song.new(@controller)._prefixes.must_equal ["test/fixtures/concepts/record/song/views", "test/fixtures/concepts/record/views"] }
-    it { Record::Cell::Hit.new(@controller)._prefixes.must_equal  ["test/fixtures/concepts/record/hit/views", "test/fixtures/concepts/record/views"]  } # with inherit_views.
+    it { Record::Cell.new._prefixes.must_equal       ["test/fixtures/concepts/record/views"] }
+    it { Record::Cell::Song.new._prefixes.must_equal ["test/fixtures/concepts/record/song/views", "test/fixtures/concepts/record/views"] }
+    it { Record::Cell::Hit.new._prefixes.must_equal  ["test/fixtures/concepts/record/hit/views", "test/fixtures/concepts/record/views"]  } # with inherit_views.
   end
 
-  it { Record::Cell.new(@controller, "Wayne").call(:show).must_equal "Party on, Wayne!" }
+  it { Record::Cell.new("Wayne").call(:show).must_equal "Party on, Wayne!" }
 
 
-  describe "#cell" do
-    it { Cell::Concept.cell("record/cell", @controller).must_be_instance_of(      Record::Cell) }
-    it { Cell::Concept.cell("record/cell/song", @controller).must_be_instance_of  Record::Cell::Song }
+  describe "::cell" do
+    it { Cell::Concept.cell("record/cell").must_be_instance_of(      Record::Cell) }
+    it { Cell::Concept.cell("record/cell/song").must_be_instance_of  Record::Cell::Song }
     # cell("song", concept: "record/compilation") # record/compilation/cell/song
   end
 
   describe "#render" do
-    it { Cell::Concept.cell("record/cell/song", @controller).show.must_equal "Lalala" }
+    it { Cell::Concept.cell("record/cell/song").show.must_equal "Lalala" }
+  end
+
+  describe "#cell (in cell state)" do
+    # test with controller, but remove tests when we don't need it anymore.
+    it { Cell::Concept.cell("record/cell", nil, controller: Object).cell("record/cell", nil, tracks: 24).(:description).must_equal "A Tribute To Rancid, with 24 songs! [Object]" }
+    it { Cell::Concept.cell("record/cell", nil, controller: Object).concept("record/cell", nil, tracks: 24).(:description).must_equal "A Tribute To Rancid, with 24 songs! [Object]" }
+    # concept(.., collection: ..)
+    it("xx")  { Cell::Concept.cell("record/cell", nil, controller: Object).
+      concept("record/cell", collection: [1,2], tracks: 24, method: :description).must_equal "A Tribute To Rancid, with 24 songs! [Object]A Tribute To Rancid, with 24 songs! [Object]" }
   end
 end

data/test/dummy/config/application.rb

@@ -21,7 +21,7 @@ module Dummy
     # enable asset pipeline as in development.
     config.assets.enabled = true
     config.assets.compile = true
-    config.cells.with_assets = ["album", "song"]
+    # config.cells.with_assets = ["song/cell"]
     config.cache_classes = true
 
     # Show full error reports and disable caching

data/test/public_test.rb

@@ -2,8 +2,7 @@ require 'test_helper'
 
 class PublicTest < MiniTest::Spec
   class SongCell < Cell::ViewModel
-    def initialize(controller, *args)
-      @parent_controller = controller # TODO: this is removed in 4.0.
+    def initialize(*args)
       @initialize_args = *args
     end
     attr_reader :initialize_args
@@ -18,25 +17,25 @@ class PublicTest < MiniTest::Spec
   end
 
   # ViewModel.cell returns the cell instance.
-  it { Cell::ViewModel.cell("public_test/song", nil).must_be_instance_of SongCell }
+  it { Cell::ViewModel.cell("public_test/song").must_be_instance_of SongCell }
 
   # ViewModel.cell passes options to cell.
-  it { Cell::ViewModel.cell("public_test/song", nil, Object, genre: "Metal").initialize_args.must_equal [Object, {:genre=>"Metal"}] }
+  it { Cell::ViewModel.cell("public_test/song", Object, genre: "Metal").initialize_args.must_equal [Object, {:genre=>"Metal"}] }
 
   # ViewModel.cell(collection: []) renders cells.
-  it { Cell::ViewModel.cell('public_test/song', nil, collection: [Object, Module]).must_equal '[Object, {}][Module, {}]' }
+  it { Cell::ViewModel.cell('public_test/song', collection: [Object, Module]).must_equal '[Object, {}][Module, {}]' }
 
   # ViewModel.cell(collection: []) renders cells with custom join.
-  it { Cell::ViewModel.cell('public_test/song', nil, collection: [Object, Module], collection_join: '<br/>').must_equal '[Object, {}]<br/>[Module, {}]' }
+  it { Cell::ViewModel.cell('public_test/song', collection: [Object, Module], collection_join: '<br/>').must_equal '[Object, {}]<br/>[Module, {}]' }
 
   # ViewModel.cell(collection: []) renders html_safe.
-  it { Cell::ViewModel.cell("public_test/song", nil, collection: [Object]).class.must_equal ActiveSupport::SafeBuffer }
+  it { Cell::ViewModel.cell("public_test/song", collection: [Object]).class.must_equal ActiveSupport::SafeBuffer }
 
   # ViewModel.cell(collection: []) passes generic options to cell.
-  it { Cell::ViewModel.cell('public_test/song', nil, collection: [Object, Module], genre: 'Metal').must_equal "[Object, {:genre=>\"Metal\"}][Module, {:genre=>\"Metal\"}]" }
+  it { Cell::ViewModel.cell('public_test/song', collection: [Object, Module], genre: 'Metal').must_equal "[Object, {:genre=>\"Metal\"}][Module, {:genre=>\"Metal\"}]" }
 
   # ViewModel.cell(collection: [], method: :detail) invokes #detail instead of #show.
-  it { Cell::ViewModel.cell('public_test/song', nil, collection: [Object, Module], method: :detail).must_equal '* [Object, {}]* [Module, {}]' }
+  it { Cell::ViewModel.cell('public_test/song', collection: [Object, Module], method: :detail).must_equal '* [Object, {}]* [Module, {}]' }
 end
 
 # TODO: test AV::concept.