cells 3.10.1 → 3.11.0

data/lib/cell/base/prefixes.rb

@@ -0,0 +1,27 @@
+# TODO: merge into Rails core.
+# TODO: cache _prefixes on class layer.
+module Cell::Base::Prefixes
+  extend ActiveSupport::Concern
+
+  def _prefixes
+    self.class._prefixes
+  end
+
+  module ClassMethods
+    def _prefixes
+      return [] if abstract?
+      _local_prefixes + superclass._prefixes
+    end
+
+    def _local_prefixes
+      [controller_path]
+    end
+
+    # Instructs Cells to inherit views from a parent cell without having to inherit class code.
+    def inherit_views(parent)
+      define_method :_prefixes do
+        super() + parent._prefixes
+      end
+    end
+  end
+end

data/lib/cell/base/self_contained.rb

@@ -0,0 +1,13 @@
+# Enforces the new trailblazer directory layout where cells (or concepts in general) are
+# fully self-contained in its own directory.
+module Cell::Base::SelfContained
+  def self_contained!
+    extend Prefixes
+  end
+
+  module Prefixes
+    def _local_prefixes
+      super.collect { |prefix| "#{prefix}/views" }
+    end
+  end
+end

data/lib/cell/base/view.rb

@@ -0,0 +1,15 @@
+class Cell::Base::View < ActionView::Base
+  def self.prepare(modules)
+    # TODO: remove for 4.0 if PR https://github.com/rails/rails/pull/6826 is merged.
+    Class.new(self) do  # DISCUSS: why are we mixing that stuff into this _anonymous_ class at all? that makes things super complicated.
+      include *modules.reverse
+    end
+  end
+
+  def render(*args, &block)
+    options = args.first.is_a?(::Hash) ? args.first : {}  # this is copied from #render by intention.
+
+    return controller.render(*args, &block) if options[:state] or options[:view]
+    super
+  end
+end

data/lib/cell/builder.rb

@@ -1,72 +1,71 @@
 module Cell
   # Contains all methods for dynamically building a cell instance by using decider blocks.
-  module Builder
+  #
+  # Design notes:
+  # * totally generic, doesn't know about parent_controller etc.
+  # * only dependency: constant.builders (I wanted to hide this from Cell::Base)
+  # * can easily be replaced or removed.
+  class Builder
+    def initialize(constant, exec_context) # TODO: evaluate usage of builders and implement using Uber::Options::Value.
+      @constant     = constant
+      @exec_context = exec_context
+      @builders     = @constant.builders # only dependency, must be a Cell::Base subclass.
+    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(name, *args)
-      class_from_cell_name(name).build_for(*args)
-    end # TODO: rename to #cell_for.
-    alias_method :cell_for, :create_cell_for
-
-    def build_for(*args)  # DISCUSS: remove?
+    def call(*args)
       build_class_for(*args).
-      create_cell(*args)
-    end
-
-    # Adds a builder to the cell class. Builders are used in #render_cell to find out the concrete
-    # class for rendering. This is helpful if you frequently want to render subclasses according
-    # to different circumstances (e.g. login situations) and you don't want to place these deciders in
-    # your view code.
-    #
-    # Passes the opts hash from #render_cell into the block. The block is executed in controller context.
-    # Multiple build blocks are ORed, if no builder matches the building cell is used.
-    #
-    # Example:
-    #
-    # Consider two different user box cells in your app.
-    #
-    #   class AuthorizedUserBox < UserInfoBox
-    #   end
-    #
-    #   class AdminUserBox < UserInfoBox
-    #   end
-    #
-    # Now you don't want to have deciders all over your views - use a declarative builder.
-    #
-    #   UserInfoBox.build do |opts|
-    #     AuthorizedUserBox if user_signed_in?
-    #     AdminUserBox if admin_signed_in?
-    #   end
-    #
-    # In your view #render_cell will instantiate the right cell for you now.
-    def build(&block)
-      builders << block
-    end
-
-    # The cell class constant for +cell_name+.
-    def class_from_cell_name(cell_name)
-      "#{cell_name}_cell".classify.constantize
-    end
-
-    # Override this if you want to receive arguments right in the cell constructor.
-    def create_cell(*args)
       new(*args)
     end
 
   private
     def build_class_for(*args)
-      builders.each do |blk|
+      @builders.each do |blk|
         klass = run_builder_block(blk, *args) and return klass
       end
-      self
+      @constant
     end
 
     def run_builder_block(block, *args)
-      block.call(*args)
+      @exec_context.instance_exec(*args, &block)
     end
 
-    def builders
-      @builders ||= []
-    end
+
+    module ClassMethods
+      # Adds a builder to the cell class. Builders are used in #render_cell to find out the concrete
+      # class for rendering. This is helpful if you frequently want to render subclasses according
+      # to different circumstances (e.g. login situations) and you don't want to place these deciders in
+      # your view code.
+      #
+      # Passes the opts hash from #render_cell into the block. The block is executed in controller context.
+      # Multiple build blocks are ORed, if no builder matches the building cell is used.
+      #
+      # Example:
+      #
+      # Consider two different user box cells in your app.
+      #
+      #   class AuthorizedUserBox < UserInfoBox
+      #   end
+      #
+      #   class AdminUserBox < UserInfoBox
+      #   end
+      #
+      # Now you don't want to have deciders all over your views - use a declarative builder.
+      #
+      #   UserInfoBox.build do |opts|
+      #     AuthorizedUserBox if user_signed_in?
+      #     AdminUserBox if admin_signed_in?
+      #   end
+      #
+      # In your view #render_cell will instantiate the right cell for you now.
+      def build(&block)
+        builders << block
+      end
+
+      def builders
+        @builders ||= []
+      end
+    end # ClassMethods
   end
 end

data/lib/cell/caching.rb

@@ -50,9 +50,7 @@ module Cell
       key     = self.class.state_cache_key(state, self.class.version_procs[state].evaluate(self, *args))
       options = self.class.cache_options.eval(state, self, *args)
 
-      cache_store.fetch(key, options) do
-        super(state, *args)
-      end
+      fetch_from_cache_for(key, options) { super(state, *args) }
     end
 
     def cache_configured?
@@ -67,8 +65,27 @@ module Cell
     end
 
   private
+    def fetch_from_cache_for(key, options)
+      cache_store.fetch(key, options) do
+        yield
+      end
+    end
+
     def state_cached?(state)
       self.class.version_procs.has_key?(state)
     end
-  end
+
+
+    module Notifications
+      def fetch_from_cache_for(key, options)
+        ActiveSupport::Notifications.instrument("read_fragment.action_controller", :key => key) do
+          cache_store.fetch(key, options) do
+            ActiveSupport::Notifications.instrument("write_fragment.action_controller", :key => key) do
+              yield
+            end
+          end
+        end
+      end
+    end
+  end # Caching
 end

data/lib/cell/concept.rb

@@ -0,0 +1,85 @@
+# TODO: deprecate parent_controller, ViewModel
+class Cell::Concept < Cell::ViewModel
+  abstract!
+
+  # TODO: this should be in Helper or something. this should be the only entry point from controller/view.
+  class << self
+    def cell_for(name, controller, *args)
+      Cell::Builder.new(name.classify.constantize, controller).call(controller, *args)
+    end
+
+    def controller_path
+      # TODO: cache on class level
+      # DISCUSS: only works with trailblazer style directories. this is a bit risky but i like it.
+      # applies to Comment::Cell, Comment::Cell::Form, etc.
+      name.sub(/::Cell/, '').underscore unless anonymous?
+    end
+  end
+
+  def concept(name, *args, &block)
+    self.class.cell(name, parent_controller, *args, &block)
+  end
+
+  self_contained!
+
+  # DISCUSS: experimental, allows to render layouts from the partial view directory instead of a global one.
+  module Rendering
+    def view_renderer
+      @_view_renderer ||= Renderer.new(lookup_context)
+    end
+
+    if Cell.rails_version >= 3.2
+      def _normalize_layout(value) # 3.2+
+        value
+      end
+    else
+      def _normalize_options(options) # FIXME: for rails 3.1, only. in 3.2+ it's _normalize_layout.
+        super
+
+        if options[:layout]
+          options[:layout].sub!("layouts/", "")
+        end
+      end
+    end
+  end
+
+  class Renderer < ActionView::Renderer
+    def render_template(context, options) # Rails 4.0 # FIXME: make that simpler to override in rails core.
+      TemplateRenderer.new(@lookup_context).render(context, options)
+    end
+
+    def _template_renderer # Rails 3.x
+      @_template_renderer ||= TemplateRenderer.new(@lookup_context)
+    end
+
+
+    class TemplateRenderer < ActionView::TemplateRenderer
+      def render(context, options)
+        @options = options
+        super
+      end
+
+      def find_layout(layout, keys)
+        resolve_layout(layout, keys, [formats.first])
+      end
+
+      def resolve_layout(layout, keys, formats)
+        details = @details ? @details.dup : {} # FIXME: provide the entire Renderer layer here. this is to make it compatible with Rails 3.1.
+        details[:formats] = formats
+
+        case layout
+        when String
+          find_args = [layout, @options[:prefixes], false, keys, details]
+          find_args = [layout, @options[:prefixes], false, keys] if Cell.rails_version.~ 3.1
+          find_template(*find_args)
+        when Proc
+          resolve_layout(layout.call, keys, formats)
+        else
+          layout
+        end
+      end
+    end
+  end # Rendering
+
+  include Rendering
+end

data/lib/cell/rails.rb

@@ -8,6 +8,12 @@ module Cell
     abstract!
     delegate :session, :params, :request, :config, :env, :url_options, :to => :parent_controller
 
+    class Builder < Cell::Builder
+      def run_builder_block(block, controller, *args)
+        super(block, *args)
+      end
+    end
+
     class << self
       def cache_store
         # FIXME: i'd love to have an initializer in the cells gem that _sets_ the cache_store attr instead of overriding here.
@@ -20,10 +26,11 @@ module Cell
         expire_cache_key_for(key, cache_store ,*args)
       end
 
-    private
-      # Run builder block in controller instance context.
-      def run_builder_block(block, controller, *args)
-        controller.instance_exec(*args, &block)
+      # Main entry point for instantiating cells.
+
+      def cell_for(name, controller, *args)
+        # FIXME: too much redundancy from Base.
+        Builder.new(class_from_cell_name(name), controller).call(controller, *args) # use Cell::Rails::Builder.
       end
     end
 
@@ -51,7 +58,7 @@ module Cell
       end
     end
     include DSL
-
-    autoload :ViewModel, "cell/rails/view_model"
   end
 end
+
+require "cell/rails/view_model" # TODO: remove in 4.0.

data/lib/cell/rails/view_model.rb

@@ -14,14 +14,53 @@ class Cell::Rails
     # properties :title, :body
     attr_reader :model
 
+
+    def self.included(*)
+      ActiveSupport::Deprecation.warn("The Cell::Rails::ViewModel module is deprecated and will be removed in Cells 4.0. Please inherit: `class SongCell < Cell::ViewModel`. Thanks and don't forget to smile.")
+      super
+    end
+
+
+
+    module Helpers
+      # DISCUSS: highest level API method. add #cell here.
+      def collection(name, controller, array, method=:show, builder=Cell::Rails)
+        # FIXME: this is the problem in Concept cells, we don't wanna call Cell::Rails.cell_for here.
+        array.collect { |model| builder.cell_for(name, controller, model).call(method) }.join("\n").html_safe
+      end
+
+      # TODO: this should be in Helper or something. this should be the only entry point from controller/view.
+      def cell(name, controller, *args, &block) # classic Rails fuzzy API.
+        if args.first.is_a?(Hash) and array = args.first[:collection]
+          return collection(name, controller, array)
+        end
+
+        Cell::Rails.cell_for(name, controller, *args, &block)
+      end
+    end
+    extend Helpers # FIXME: do we really need ViewModel::cell/::collection ?
+
+
     module ClassMethods
       def property(*names)
         delegate *names, :to => :model
       end
+
+      include Helpers
     end
     extend ActiveSupport::Concern
 
 
+    def cell(name, *args)
+      self.class.cell(name, parent_controller, *args)
+    end
+
+
+    def initialize(*args)
+      super
+      _prepare_context # happens in AV::Base at the bottom.
+    end
+
     def render(options={})
       if options.is_a?(Hash)
         options.reverse_merge!(:view => state_for_implicit_render)
@@ -32,8 +71,10 @@ class Cell::Rails
       super
     end
 
-    def call
-      render implicit_state
+    def call(state=:show)
+      # it is ok to call to_s.html_safe here as #call is a defined rendering method.
+      # DISCUSS: IN CONCEPT: render( view: implicit_state)
+      render_state(state).to_s.html_safe
     end
 
   private
@@ -45,9 +86,9 @@ class Cell::Rails
       caller[1].match(/`(\w+)/)[1]
     end
 
-    def implicit_state
-      controller_path.split("/").last
-    end
+    # def implicit_state
+    #   controller_path.split("/").last
+    # end
   end
 
 
@@ -109,7 +150,7 @@ class Cell::Rails
   end
 
   # FIXME: fix that in rails core.
-  if Cell.rails4_0?
+  if Cell.rails_version.~("4.0", "4.1")
     include LinkToHelper
   else
     include ActionView::Helpers::UrlHelper

data/lib/cell/rendering.rb

@@ -1,12 +1,12 @@
 module Cell
   module Rendering
     extend ActiveSupport::Concern
-    
+
     # Invoke the state method for +state+ which usually renders something nice.
     def render_state(state, *args)
       process(state, *args)
     end
-    
+
     # Renders the view for the current state and returns the markup.
     # Don't forget to return the markup itself from the state method.
     #
@@ -18,7 +18,7 @@ module Cell
     # +:inline+:: Renders an inline template as state view. See ActionView::Base#render for details.
     # +:file+::   Specifies the name of the file template to render.
     # +:nothing+:: Doesn't invoke the rendering process.
-    # +:state+::  Instantly invokes another rendering cycle for the passed state and returns. You may pass arbitrary state-args to the called state.  
+    # +:state+::  Instantly invokes another rendering cycle for the passed state and returns. You may pass arbitrary state-args to the called state.
     # +:format+:: Sets a different template format, e.g. +:json+. Use this option with caution as it currently modifies the global format variable. This might lead to unexpected subsequent render behaviour due to a design flaw in Rails.
     #
     # Example:
@@ -56,7 +56,7 @@ module Cell
     #
     # === Using states instead of helpers
     #
-    # Sometimes it's useful to not only render a view but also invoke the associated state. This is 
+    # Sometimes it's useful to not only render a view but also invoke the associated state. This is
     # especially helpful when replacing helpers. Do that with <tt>render :state</tt>.
     #
     #   def show_cheap_item(item)
@@ -72,34 +72,34 @@ module Cell
     def render(*args)
       render_view_for(self.action_name, *args)
     end
-  
+
   private
     # Renders the view belonging to the given state. Will raise ActionView::MissingTemplate
     # if it can't find a view.
     def render_view_for(state, *args)
       opts = args.first.is_a?(::Hash) ? args.shift : {}
-      
+
       return "" if opts[:nothing]
-      
+
       if opts[:state]
         opts[:text] = render_state(opts.delete(:state), *args)
       elsif (opts.keys & [:text, :inline, :file]).blank?
         process_opts_for(opts, state)
       end
-      
+
       render_to_string(opts).html_safe # ActionView::Template::Text doesn't do that for us.
     end
-    
-    
+
+
     module ClassMethods
       # Main entry point for #render_cell.
       def render_cell_for(name, state, *args)
-        cell = create_cell_for(name, *args)
+        cell = cell_for(name, *args)
         yield cell if block_given?
-        
+
         render_cell_state(cell, state, *args)
       end
-    
+
     private
       def render_cell_state(cell, state, *args)
         cell.render_state(state, *args)