cells 4.0.5 → 4.1.0.rc1

data/lib/cell/builder.rb

@@ -0,0 +1,16 @@
+require "uber/builder"
+
+module Cell
+  module Builder
+    def self.included(base)
+      base.send :include, Uber::Builder
+      base.extend ClassMethods
+    end
+
+    module ClassMethods
+      def build(*args)
+        class_builder.call(*args).new(*args) # Uber::Builder::class_builder.
+      end
+    end
+  end
+end

data/lib/cell/collection.rb

@@ -0,0 +1,54 @@
+module Cell
+  class Collection
+    def initialize(ary, options, cell_class)
+      options.delete(:collection)
+      @method     = options.delete(:method)           # TODO: remove in 5.0.
+      @join       = options.delete(:collection_join)  # TODO: remove in 5.0.
+
+      @ary        = ary
+      @options    = options
+      @cell_class = cell_class
+
+      deprecate_options!
+    end
+
+    def deprecate_options! # TODO: remove in 5.0.
+      warn "[Cells] The :method option is deprecated. Please use `call(method)` as documented here: http://trailblazer.to/gems/cells/api.html#collection" if @method
+      warn "[Cells] The :collection_join option is deprecated. Please use `join(\"<br>\")` as documented here: http://trailblazer.to/gems/cells/api.html#collection" if @collection_join
+    end
+
+    module Call
+      def call(state=:show)
+        join(@join) { |cell, i| cell.(@method || state) }
+      end
+    end
+    include Call
+
+    alias to_s call
+
+    # Iterate collection and build a cell for each item.
+    # The passed block receives that cell and the index.
+    # Its return value is captured and joined.
+    def join(separator="", &block)
+      @ary.each_with_index.collect do |model, i|
+        yield @cell_class.build(model, @options), i
+      end.
+        join(separator)
+    end
+
+    module Layout
+      def call(*) # WARNING: THIS IS NOT FINAL API.
+        layout = @options.delete(:layout) # we could also override #initialize and that there?
+
+        content = super # DISCUSS: that could come in via the pipeline argument.
+        ViewModel::Layout::External::Render.(content, @ary, layout, @options)
+      end
+    end
+    include Layout
+
+  end
+end
+
+# Collection#call
+# |> Header#call
+# |> Layout#call

data/lib/cell/concept.rb

@@ -1,12 +1,16 @@
+require "cell/self_contained"
+
 module Cell
+  # Cell::Concept is no longer under active development. Please switch to Trailblazer::Cell.
   class Concept < Cell::ViewModel
     abstract!
     self.view_paths = ["app/concepts"]
+    extend SelfContained
 
     # TODO: this should be in Helper or something. this should be the only entry point from controller/view.
     class << self
       def class_from_cell_name(name)
-        name.camelize.constantize
+        util.constant_for(name)
       end
 
       def controller_path
@@ -14,12 +18,7 @@ module Cell
       end
     end
 
-    alias_method :concept, :cell # Concept#concept does exactly what #cell does: delegate to class builder.
-
-    # Get nested cell in instance.
-    def cell(name, model=nil, options={})
-      ViewModel.cell(name, model, options.merge(controller: parent_controller)) # #cell calls need to be delegated to ViewModel.
-    end
+    alias_method :concept, :cell
 
     self_contained!
   end

data/lib/cell/escaped.rb

@@ -23,6 +23,7 @@ module Cell::ViewModel::Escaped
 
   # Can be used as a helper in the cell, too.
   # Feel free to override and use a different escaping implementation.
+  require "erb"
   def escape!(string)
     ::ERB::Util.html_escape(string)
   end

data/lib/cell/layout.rb

@@ -1,20 +1,56 @@
 module Cell
-  # Set the layout per cell class. This is used in #render calls. Gets inherited to subclasses.
-  module Layout
-    def self.included(base)
-      base.extend ClassMethods
-      base.inheritable_attr :layout_name
-    end
+  class ViewModel
+    # Set the layout per cell class. This is used in #render calls. Gets inherited to subclasses.
+    module Layout
+      def self.included(base)
+        base.extend ClassMethods
+        base.inheritable_attr :layout_name
+      end
 
-    module ClassMethods
-      def layout(name)
-        self.layout_name = name
+      module ClassMethods
+        def layout(name)
+          self.layout_name = name
+        end
       end
-    end
 
-    def process_options!(options)
-      options[:layout] ||= self.class.layout_name
-      super
+    private
+      def process_options!(options)
+        options[:layout] ||= self.class.layout_name
+        super
+      end
+
+      def render_to_string(options, &block)
+        with_layout(options, super)
+      end
+
+      def with_layout(options, content)
+        return content unless layout = options[:layout]
+
+        render_layout(layout, options, content)
+      end
+
+      def render_layout(name, options, content)
+        template = find_template(options.merge view: name) # we could also allow a different layout engine, etc.
+        render_template(template, options) { content }
+      end
+
+      # Allows using a separate layout cell which will wrap the actual content.
+      # Use like cell(..., layout: Cell::Layout)
+      #
+      # Note that still allows the `render layout: :application` option.
+      module External
+        def call(*)
+          content = super
+          Render.(content, model, @options[:layout], @options)
+        end
+
+        Render = ->(content, model, layout, options) do # WARNING: THIS IS NOT FINAL API.
+          return content unless layout = layout # TODO: test when invoking cell without :layout.
+
+          # DISCUSS: should we allow instances, too? we could cache the layout cell.
+          layout.new(model, context: options[:context]).(&lambda { content })
+        end
+      end # External
     end
   end
-end
+end

data/lib/cell/testing.rb

@@ -12,13 +12,14 @@ module Cell
 
   private
     def cell_for(baseclass, name, model=nil, options={})
-      cell = baseclass.cell(name, model, options.merge(controller: controller))
+      options[:context] ||= {}
+      options[:context][:controller] = controller
 
-      if Cell::Testing.capybara? # leaving this here as most people use Capybara.
-        return ::Capybara::string(cell) unless cell.is_a?(Cell::ViewModel) # HORRIBLE hack, will be fixed with new collection API in 4.1 :)
-        cell.extend(Capybara)
-      end
+      cell = baseclass.cell(name, model, options)
 
+      cell.extend(Capybara) if Cell::Testing.capybara? # leaving this here as most people use Capybara.
+      # apparently it's ok to only override ViewModel#call and capybararize the result.
+      # when joining in a Collection, the joint will still be capybararized.
       cell
     end
 

data/lib/cell/util.rb

@@ -12,5 +12,14 @@ module Cell::Util
       tr("-", "_").
       downcase
     end
+
+    # WARNING: this API might change.
+    def self.constant_for(name)
+      constant = Object
+      name.split("/").each do |part|
+        constant = constant.const_get(part.split('_').collect(&:capitalize).join)
+      end
+      constant
+    end
   end
-end
+end

data/lib/cell/version.rb

@@ -1,3 +1,3 @@
 module Cell
-  VERSION = "4.0.5"
+  VERSION = "4.1.0.rc1"
 end

data/lib/cell/view_model.rb

@@ -3,13 +3,8 @@ module Cell
     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"]
@@ -21,7 +16,6 @@ module Cell
     end
 
     include Prefixes
-    extend SelfContained
     extend Util
 
     def self.controller_path
@@ -31,17 +25,10 @@ module Cell
     attr_reader :model
 
     module Helpers
-      # Constantizes name, call builders and returns instance.
+      # Constantizes name if needed, call builders and returns instance.
       def cell(name, *args, &block) # classic Rails fuzzy API.
-        class_from_cell_name(name).(*args, &block)
-      end
-
-    private
-      # Renders collection of cells.
-      def render_collection(array, options) # private.
-        method = options.delete(:method) || :show
-        join   = options.delete(:collection_join)
-        array.collect { |model| build(model, options).call(method) }.join(join).html_safe
+        constant = name.is_a?(Class) ? name : class_from_cell_name(name)
+        constant.(*args, &block)
       end
     end
     extend Helpers
@@ -51,82 +38,66 @@ module Cell
         delegates :model, *names # Uber::Delegates.
       end
 
-      include Helpers
-
       # Public entry point. Use this to instantiate cells with builders.
       #
       #   SongCell.(@song)
       #   SongCell.(collection: Song.all)
       def call(model=nil, options={}, &block)
-        if model.is_a?(Hash) and array = model.delete(:collection)
-          return render_collection(array, model.merge(options))
+        if model.is_a?(Hash) and array = model[:collection]
+          return Collection.new(array, model.merge(options), self)
         end
 
         build(model, options)
       end
 
-      def build(*args) # semi-public.
-        class_builder.call(*args).new(*args) # Uber::Builder::class_builder.
-      end
+      alias build new # semi-public for Cell::Builder
 
     private
       def class_from_cell_name(name)
-        "#{name}_cell".camelize.constantize
+        util.constant_for("#{name}_cell")
       end
     end
 
-    # Get nested cell in instance.
+    # Build nested cell in instance.
     def cell(name, model=nil, options={})
-      self.class.cell(name, model, options.merge(controller: parent_controller))
+      self.class.cell(name, model, options.merge(context: context))
     end
 
-    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.
-
+    def initialize(model=nil, options={})
       setup!(model, options)
     end
-    attr_reader :parent_controller
-    alias_method :controller, :parent_controller
+
+    def context # TODO: explicit test.
+      @options[:context]
+    end
 
     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?
-
+      def call(state=:show, *args, &block)
+        content = render_state(state, *args, &block)
         content.to_s
       end
 
+      # Since 4.1, you get the #show method for free.
+      def show(&block)
+        render(&block)
+      end
+
       # render :show
-      def render(options={})
+      def render(options={}, &block)
         options = normalize_options(options)
-        render_to_string(options)
+        render_to_string(options, &block)
       end
 
     private
-      def render_to_string(options)
+      def render_to_string(options, &block)
         template = find_template(options)
-
-        content  = render_template(template, options)
-
-        # TODO: allow other (global) layout dirs.
-        with_layout(options, content)
-      end
-
-      def render_state(*args)
-        __send__(*args)
+        render_template(template, options, &block)
       end
 
-      def with_layout(options, content)
-        return content unless layout = options[:layout]
-
-        template = find_template(options.merge view: layout) # we could also allow a different layout engine, etc.
-
-        render_template(template, options) { content }
+      def render_state(*args, &block)
+        __send__(*args, &block)
       end
 
       def render_template(template, options, &block)

data/lib/cells.rb

@@ -1 +1 @@
-require 'cell'
+require "cell"

data/test/builder_test.rb

@@ -5,6 +5,8 @@ class BuilderTest < MiniTest::Spec
   Hit  = Struct.new(:title)
 
   class SongCell < Cell::ViewModel
+    include Cell::Builder
+
     builds do |model, options|
       if model.is_a? Hit
         HitCell
@@ -52,10 +54,10 @@ class BuilderTest < MiniTest::Spec
   it { SongCell.(Hit.new("Frenzy")).must_be_instance_of HitCell }
 
   # with collection.
-  it { SongCell.(collection: [Song.new("Nation States"), Hit.new("New York")]).must_equal "* Nation States* **New York**" }
+  it { SongCell.(collection: [Song.new("Nation States"), Hit.new("New York")]).().must_equal "* Nation States* **New York**" }
 
   # with Concept
   class Track < Cell::Concept
   end
   it { Track.().must_be_instance_of Track }
-end
+end

data/test/cell_test.rb

@@ -2,12 +2,19 @@ require 'test_helper'
 
 class CellTest < MiniTest::Spec
   class SongCell < Cell::ViewModel
+    self.view_paths = ['test/fixtures']
+
     def show
     end
+
+    def show_with_block(&block)
+      render(&block)
+    end
   end
-  # ::rails_version
-  it { Cell.rails_version.must_equal Gem::Version.new(ActionPack::VERSION::STRING) }
 
   # #options
   it { SongCell.new(nil, genre: "Punkrock").send(:options)[:genre].must_equal "Punkrock" }
+
+  # #block
+  it { SongCell.new(nil, genre: "Punkrock").(:show_with_block) { "hello" }.must_equal "<b>hello</b>\n" }
 end

data/test/concept_test.rb

@@ -27,7 +27,7 @@ module Record
 
 
     def description
-      "A Tribute To Rancid, with #{@options[:tracks]} songs! [#{parent_controller}]"
+      "A Tribute To Rancid, with #{@options[:tracks]} songs! [#{context}]"
     end
   end
 end
@@ -48,10 +48,10 @@ end
 
 class ConceptTest < MiniTest::Spec
   describe "::controller_path" do
-    it { Record::Cell.new.controller_path.must_equal "record" }
-    it { Record::Cell::Song.new.controller_path.must_equal "record/song" }
-    it { Record::Cells::Cell.new.controller_path.must_equal "record/cells" }
-    it { Record::Cells::Cell::Song.new.controller_path.must_equal "record/cells/song" }
+    it { Record::Cell.new.class.controller_path.must_equal "record" }
+    it { Record::Cell::Song.new.class.controller_path.must_equal "record/song" }
+    it { Record::Cells::Cell.new.class.controller_path.must_equal "record/cells" }
+    it { Record::Cells::Cell::Song.new.class.controller_path.must_equal "record/cells/song" }
   end
 
 
@@ -74,19 +74,12 @@ class ConceptTest < MiniTest::Spec
     it { Cell::Concept.cell("record/cell/song").show.must_equal "Lalala" }
   end
 
-
-  class RecordCell < Cell::ViewModel
-    def description
-      "Record! A Tribute To Rancid, with #{@options[:tracks]} songs! [#{parent_controller}]"
-    end
-  end
-
   describe "#cell (in 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("concept_test/record", nil, tracks: 24).(:description).must_equal "Record! 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]" }
+    it { Cell::Concept.cell("record/cell", nil, context: { controller: Object }).cell("record/cell", nil).must_be_instance_of Record::Cell }
+    it { Cell::Concept.cell("record/cell", nil, context: { controller: Object }).concept("record/cell", nil, tracks: 24).(:description).must_equal "A Tribute To Rancid, with 24 songs! [{:controller=>Object}]" }
     # concept(.., collection: ..)
-    it { 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]" }
+    it { Cell::Concept.cell("record/cell", nil, context: { controller: Object }).
+      concept("record/cell", collection: [1,2], tracks: 24, method: :description).().must_equal "A Tribute To Rancid, with 24 songs! [{:controller=>Object}]A Tribute To Rancid, with 24 songs! [{:controller=>Object}]" }
   end
 end