cells 3.11.3 → 4.0.0.beta1

data/lib/cell/railtie.rb

@@ -0,0 +1,60 @@
+begin
+  require 'rails/railtie'
+rescue LoadError
+else
+  module Cell
+    class Railtie < Rails::Railtie
+      require 'cell/rails'
+      config.cells = ActiveSupport::OrderedOptions.new
+
+      initializer('cells.attach_router') do |app|
+        ViewModel.class_eval do
+          include app.routes.url_helpers # TODO: i hate this, make it better in Rails.
+        end
+      end
+
+      initializer 'cells.template_engine' do |app|
+        ViewModel.template_engine = app.config.app_generators.rails.fetch(:template_engine, 'erb').to_s
+      end
+
+      # ruthlessly stolen from the zurb-foundation gem.
+      initializer 'cells.update_asset_paths' do |app|
+        Array(app.config.cells.with_assets).each do |name|
+          # FIXME: this doesn't take engine cells into account.
+          app.config.assets.paths.append "#{app.root}/app/cells/#{name}/assets"
+          app.config.assets.paths.append "#{app.root}/app/concepts/#{name}/assets" # TODO: find out type.
+        end
+      end
+
+      initializer('cells.rails_extensions') do |app|
+        ActiveSupport.on_load(:action_controller) do
+          self.class_eval do
+            include ::Cell::RailsExtensions::ActionController
+          end
+        end
+
+        ActiveSupport.on_load(:action_view) do
+          self.class_eval do
+            include ::Cell::RailsExtensions::ActionView
+          end
+
+          #include assert helpers (image_path, font_path, ect)
+          ViewModel.class_eval do
+            include ActionView::Helpers::AssetTagHelper
+          end
+        end
+      end
+
+      initializer('cells.development') do |app|
+        if Rails.env == "development"
+          require "cell/development"
+          ViewModel.send(:include, Development)
+        end
+      end
+
+      rake_tasks do
+        load 'tasks/cells.rake'
+      end
+    end
+  end
+end

data/lib/cell/{base/self_contained.rb → self_contained.rb}

@@ -1,6 +1,6 @@
 # Enforces the new trailblazer directory layout where cells (or concepts in general) are
 # fully self-contained in its own directory.
-module Cell::Base::SelfContained
+module Cell::SelfContained
   def self_contained!
     extend Prefixes
   end

data/lib/cell/templates.rb

@@ -0,0 +1,60 @@
+module Cell
+  # Gets cached in production.
+  class Templates
+    # prefixes could be instance variable as they will never change.
+    def [](bases, prefixes, view, engine, formats=nil)
+      base = bases.first # FIXME.
+
+      find_template(base, prefixes, view, engine)
+    end
+
+  private
+
+    def cache
+      @cache ||= Cache.new
+    end
+
+    def find_template(base, prefixes, view, engine)
+      view = "#{view}.#{engine}"
+
+      cache.fetch(prefixes, view) do |prefix|
+        # this block is run once per cell class per process, for each prefix/view tuple.
+        create(base, prefix, view)
+      end
+    end
+
+    def create(base, prefix, view)
+      # puts "...checking #{base}/#{prefix}/#{view}"
+      return unless File.exists?("#{base}/#{prefix}/#{view}") # DISCUSS: can we use Tilt.new here?
+      Tilt.new("#{base}/#{prefix}/#{view}", :escape_html => false, :escape_attrs => false)
+    end
+
+    # {["comment/row/views", comment/views"][show.haml] => "Tpl:comment/view/show.haml"}
+    class Cache
+      def initialize
+        @store = {}
+      end
+
+      # Iterates prefixes and yields block. Returns and caches when block returned template.
+      # Note that it caches per prefixes set as this will most probably never change.
+      def fetch(prefixes, view)
+        template = get(prefixes, view) and return template # cache hit.
+
+        prefixes.find do |prefix|
+          template = yield(prefix) and return store(prefixes, view, template)
+        end
+      end
+
+    private
+      # ["comment/views"] => "show.haml"
+      def get(prefixes, view)
+        @store[prefixes] ||= {}
+        @store[prefixes][view]
+      end
+
+      def store(prefix, view, template)
+        @store[prefix][view] = template # the nested hash is always present here.
+      end
+    end
+  end
+end

data/lib/cell/test_case.rb

@@ -1,168 +1,10 @@
+require "cell/testing"
+
 module Cell
   # Test your cells.
   #
-  # This class is roughly equal to ActionController::TestCase, exposing the same semantics. It will try
-  # to infer the tested cell name from the test name if you use declarative testing. You can also set it
-  # with TestCase.tests.
-  #
-  # A declarative test would look like
-  #
-  #   class SellOutTest < Cell::TestCase
-  #     tests ShoppingCartCell
-  #
-  #     it "should be rendered nicely" do
-  #       invoke :order_button, :items => @fixture_items
-  #
-  #       assert_select "button", "Order now!"
-  #     end
-  #
-  # You can also do stuff yourself, like
-  #
-  #     it "should be rendered even nicer" do
-  #       html = render_cell(:shopping_cart, :order_button, , :items => @fixture_items)
-  #       assert_selector "button", "Order now!", html
-  #     end
-  #
-  # Or even unit test your cell:
-  #
-  #     it "should provide #default_items" do
-  #       assert_equal [@item1, @item2], cell(:shopping_cart).default_items
-  #     end
-  #
-  # == Test helpers
-  #
-  # Basically, we got these new methods:
-  #
-  # +invoke+::  Renders the passed +state+ with your tested cell. You may pass options like in #render_cell.
-  # +render_cell+:: As in your views. Will return the rendered view.
-  # +assert_selector+:: Like #assert_select except that the last argument is the html markup you wanna test.
-  # +cell+:: Gives you a cell instance for unit testing and stuff.
+  # TODO: document me, Capybara, etc.
   class TestCase < ActiveSupport::TestCase
-    module AssertSelect
-      # Invokes assert_select for the last argument, the +content+ string.
-      #
-      # Example:
-      #   assert_selector "h1", "The latest and greatest!", "<h1>The latest and greatest!</h1>"
-      #
-      # would be true.
-      def assert_selector(*args, &block)
-        rails_assert_select(HTML::Document.new(args.pop).root, *args, &block)
-      end
-
-      # Invokes assert_select on the markup set by the last #invoke.
-      #
-      # Example:
-      #   invoke :latest
-      #   assert_select "h1", "The latest and greatest!"
-      def assert_select(*args, &block)
-        super(HTML::Document.new(last_invoke).root, *args, &block)
-      end
-    end
-
-    module CommonTestMethods
-      def setup
-        @controller ||= Class.new(ActionController::Base).new
-        @request    ||= ::ActionController::TestRequest.new
-        @response   = ::ActionController::TestResponse.new
-        @controller.request = @request
-        @controller.response = @response
-        @controller.params = {}
-      end
-
-      # Runs the block while computing the instance variables diff from before and after.
-      def extract_state_ivars_for(cell)
-        before  = cell.instance_variables
-        yield
-        after   = cell.instance_variables
-
-        Hash[(after - before).collect do |var|
-          next if var =~ /^@_/
-          [var[1, var.length].to_sym, cell.instance_variable_get(var)]
-        end.compact]
-      end
-    end
-
-
-    module TestMethods
-      include CommonTestMethods
-
-      attr_reader :last_invoke, :subject_cell, :view_assigns
-
-      # Use this for functional tests of your application cells.
-      #
-      # Example:
-      #   should "spit out a h1 title" do
-      #     html = render_cell(:news, :latest)
-      #     assert_select html, "h1", "The latest and greatest!"
-      def render_cell(name, state, *args)
-        # DISCUSS: should we allow passing a block here, just as in controllers?
-        @subject_cell = ::Cell::Rails.cell_for(name, @controller, *args)
-        @view_assigns = extract_state_ivars_for(@subject_cell) do
-          @last_invoke = @subject_cell.render_state(state, *args)
-        end
-
-        @last_invoke
-      end
-
-      # Builds an instance of <tt>name</tt>Cell for unit testing.
-      # Passes the optional block to <tt>cell.instance_eval</tt>.
-      #
-      # Example:
-      #   assert_equal "Doo Dumm Dumm..." cell(:bassist).play
-      def cell(name, *args, &block)
-        Cell::Rails.cell_for(name, @controller, *args).tap do |cell|
-          cell.instance_eval &block if block_given?
-        end
-      end
-
-      # Execute the passed +block+ in a real view context of +cell_class+.
-      # Usually you'd test helpers here.
-      #
-      # Example:
-      #
-      #   assert_equal("<h1>Modularity rocks.</h1>", in_view do content_tag(:h1, "Modularity rocks."))
-      def in_view(cell_class, &block)
-        subject = cell(cell_class)
-        setup_test_states_in(subject) # add #in_view to subject cell.
-        subject.render_state(:in_view, block)
-      end
-
-    protected
-      def setup_test_states_in(cell)
-        cell.instance_eval do
-          def in_view(block=nil)
-            render :inline => "<%= instance_exec(&block) %>", :locals => {:block => block}
-          end
-        end
-      end
-    end
-
-    include TestMethods
-    # imports "their" #assert_select.
-    if ::Rails.const_defined?(:Dom)
-      include ::Rails::Dom::Testing::Assertions::SelectorAssertions
-    else
-      include ActionDispatch::Assertions::SelectorAssertions
-    end
-    alias_method :rails_assert_select, :assert_select # i hate that.
-    include AssertSelect
-
-    extend ActionController::TestCase::Behavior::ClassMethods
-    class_attribute :_controller_class
-
-
-    def invoke(state, *args)
-      @last_invoke = self.class.controller_class.new(@controller).render_state(state, *args)
-    end
-
-    if Cell.rails_version.~("4.0", "4.1")
-      include ActiveSupport::Testing::ConstantLookup
-      def self.determine_default_controller_class(name) # FIXME: fix that in Rails 4.x.
-        determine_constant_from_test_name(name) do |constant|
-          Class === constant #&& constant < ActionController::Metal
-        end
-      end
-    end
-
+    include Testing
   end
 end

data/lib/cell/testing.rb

@@ -0,0 +1,15 @@
+# Used in rspec-cells, etc.
+module Cell
+  module Testing
+    def cell(name, *args)
+      ViewModel.cell_for(name, controller, *args)
+    end
+
+    def concept(name, *args)
+      Concept.cell_for(name, controller, *args)
+    end
+
+    def controller
+    end
+  end
+end

data/lib/cell/twin.rb

@@ -1,38 +1,20 @@
 require 'disposable/twin'
-require 'disposable/twin/option'
-module Cell
-  class Twin < Disposable::Twin
-    include Option
 
-    def self.property_names
-      representer_class.representable_attrs.collect(&:name)
+module Cell
+  module Twin
+    def self.included(base)
+      base.send :include, Disposable::Twin::Builder
+      base.extend ClassMethods
     end
 
-    module Properties
-      def self.included(base)
-        base.extend Uber::InheritableAttr
-        base.inheritable_attr :twin_class
-        base.extend ClassMethods
-      end
-
-      module ClassMethods
-        def properties(twin_class)
-          twin_class.property_names.each { |name| property name }
-          self.twin_class = twin_class
-        end
-
-        alias_method :twin, :properties
+    module ClassMethods
+      def twin(twin_class)
+        super(twin_class) { |dfn| property dfn.name } # create readers to twin model.
       end
+    end
 
-      def initialize(controller, model, options={})
-        super(controller, build_twin(model, options))
-      end
-
-    private
-
-      def build_twin(*args)
-        self.class.twin_class.new(*args)
-      end
+    def initialize(controller, model, options={})
+      super(controller, build_twin(model, options))
     end
   end
 end

data/lib/cell/version.rb

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

data/lib/cell/view_model.rb

@@ -1,3 +1,6 @@
+# FIXME: remove AC dependency by delegating forgery
+require 'action_controller'
+
 # no helper_method calls
 # no instance variables
 # no locals
@@ -5,121 +8,226 @@
 # call "helpers" in class
 
 # TODO: warn when using ::property but not passing in model in constructor.
-require 'uber/delegates'
+module Cell
+  class ViewModel < AbstractController::Base
+    abstract!
+
+    extend Uber::InheritableAttr
+    extend Uber::Delegates
+
+    inheritable_attr :view_paths
+    self.view_paths = ["app/cells"] # DISCUSS: provide same API as rails?
+
+    inheritable_attr :template_engine
+    self.template_engine = "erb"
 
-# ViewModel is only supported in Rails +3.1. If you need it in Rails 3.0, let me know.
-class Cell::ViewModel < Cell::Rails
-  abstract!
+    class << self
+      def templates
+        @templates ||= Templates.new # note: this is shared in subclasses. do we really want this?
+      end
+    end
 
-  extend Uber::Delegates
 
-  include Cell::OptionsConstructor
-  #include ActionView::Helpers::UrlHelper
-  include ActionView::Context # this includes CompiledTemplates, too.
-  # properties :title, :body
-  attr_reader :model
+    include Prefixes
+    extend SelfContained
 
+    include Uber::Builder
 
 
-  module Helpers
-    # DISCUSS: highest level API method. add #cell here.
-    def collection(name, controller, array, method=:show)
-      # FIXME: this is the problem in Concept cells, we don't wanna call Cell::Rails.cell_for here.
-      array.collect { |model| cell_for(name, controller, model).call(method) }.join("\n").html_safe
+    def self.controller_path
+      @controller_path ||= name.sub(/Cell$/, '').underscore
     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)
+    include ActionController::RequestForgeryProtection
+    delegate :session, :params, :request, :config, :env, :url_options, :to => :parent_controller
+
+    attr_reader :model
+
+
+    module Helpers
+      # Renders collection of cells.
+      def cells_collection(name, controller, array, options)
+        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
       end
 
-      cell_for(name, controller, *args, &block)
+      # Returns cell instance.
+      def cell(name, controller, 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)
+        end
+
+        cell_for(name, controller, model, options, &block)
+      end
     end
-  end
-  extend Helpers # FIXME: do we really need ViewModel::cell/::collection ?
+    extend Helpers
+
+
+    class << self
+      def property(*names)
+        delegates :model, *names # Uber::Delegates.
+      end
+
+      include Helpers
 
 
-  class << self
-    def property(*names)
-      delegates :model, *names # Uber::Delegates.
+      def cell_for(name, controller, *args)
+        class_from_cell_name(name).build_cell(controller, *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.
+      end
     end
 
-    include Helpers
-  end
+    def cell(name, *args)
+      self.class.cell(name, parent_controller, *args)
+    end
 
-  def cell(name, *args)
-    self.class.cell(name, parent_controller, *args)
-  end
 
+    def initialize(controller, model=nil, options={})
+      @parent_controller = controller # TODO: this is removed in 4.0.
 
-  def initialize(*args)
-    super
-    _prepare_context # happens in AV::Base at the bottom.
-  end
+      setup!(model, options)
+    end
+    attr_reader :parent_controller
+    alias_method :controller, :parent_controller
 
-  # render :show
-  def render(options={})
-    options = options_for(options, caller) # TODO: call render methods with call(:show), call(:comments) instead of directly #comments?
 
-    super
-  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
 
-  # Invokes the passed state (defaults to :show) by using +render_state+. This will respect caching.
-  # Yields +self+ (the cell instance) to an optional block.
-  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)
-    content = render_state(state)
-    yield self if block_given?
-    content.to_s.html_safe
-  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
-  def view_context
-    self
-  end
 
-  def options_for(options, caller)
-    if options.is_a?(Hash)
-      options.reverse_merge(:view => state_for_implicit_render(caller)) # TODO: test implicit render!
-    else
-      {:view => options.to_s}
+    # 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?
+
+      content.to_s.html_safe
     end
-  end
 
-  def state_for_implicit_render(caller)
-    caller[0].match(/`(\w+)/)[1]
-  end
+    alias_method :to_s, :call
+
+  private
+    attr_reader :options
+
+    def setup!(model, options)
+      @model   = model
+      @options = options
+      # or: create_twin(model, options)
+    end
+
+    module Rendering
+      def render_state(*args)
+        send(*args)
+      end
+    end
+    include Rendering
+    include Caching
+
+    def output_buffer
+      @output_buffer ||= []
+    end
+    attr_writer :output_buffer # TODO: test that, this breaks in MM.
+
+    module TemplateFor
+      def template_for(options)
+        view      = options[:view]
+        engine    = options[:template_engine]
+        base      = options[:base]
+        prefixes  = options[:prefixes]
+
+        # we could also pass _prefixes when creating class.templates, because prefixes are never gonna change per instance. not too sure if i'm just assuming this or if people need that.
+        self.class.templates[base, prefixes, view, engine] or raise TemplateMissingError.new(base, prefixes, view, engine, nil)
+      end
+    end
+    include TemplateFor
+
+    def with_layout(options, content)
+      return content unless layout = options[:layout]
 
-  # def implicit_state
-  #   controller_path.split("/").last
-  # end
-
-
-  # 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.~("4.0", "4.1")
-    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!)
+      template = template_for(options.merge :view => layout) # we could also allow a different layout engine, etc.
+      template.render(self) { content }
+    end
+
+    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: test implicit render!
       else
-        polymorphic_url(options)
+        {:view => options.to_s}
+      end
+
+      options[:template_engine] ||= self.class.template_engine # DISCUSS: in separate method?
+      options[:base]            ||= self.class.view_paths
+      options[:prefixes]        ||= _prefixes
+
+      process_options!(options)
+      options
+    end
+
+    # Overwrite #process_options in included feature modules, but don't forget to call +super+.
+    module ProcessOptions
+      def process_options!(options)
       end
     end
-    public :url_for
-  else
-    include ActionView::Helpers::UrlHelper
-  end
+    include ProcessOptions
 
-end
+
+    def state_for_implicit_render(caller)
+      caller[0].match(/`(\w+)/)[1]
+    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