cells 3.11.3 → 4.0.0.beta1

data/Rakefile

@@ -8,6 +8,6 @@ task :default => :test
 
 Rake::TestTask.new(:test) do |test|
   test.libs << 'test'
-  test.test_files = FileList['test/*_test.rb', 'test/rails/*_test.rb']
+  test.pattern = 'test/*_test.rb'
   test.verbose = true
 end

data/TODO.md

@@ -1,5 +1,8 @@
 # 4.0
 
+* Add tests for with_assets config
+
+
 * Get rid of the annoying `ActionController` dependency that needs to be passed into each cell. We only need it for "contextual links", when people wanna link to the same page. Make them pass in a URL generator object as a normal argument instead.
 * Generated cells will be view models per default.
 * Introduce Composition as in Reform, Representable, etc, when passing in a hash.

data/cells.gemspec

@@ -1,35 +1,26 @@
 lib = File.expand_path('../lib/', __FILE__)
 $:.unshift lib unless $:.include?(lib)
 
-require 'cells/version'
+require 'cell/version'
 
-Gem::Specification.new do |s|
-  s.name        = "cells"
-  s.version     = Cells::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = ["Nick Sutterer"]
-  s.email       = ["apotonick@gmail.com"]
-  s.homepage    = "http://cells.rubyforge.org"
-  s.summary     = %q{View Components for Rails.}
-  s.description = %q{Cells are view components for Rails. They are lightweight controllers, can be rendered in views and thus provide an elegant and fast way for encapsulation and component-orientation.}
-  s.license     = 'MIT'
+Gem::Specification.new do |spec|
+  spec.name        = "cells"
+  spec.version     = Cell::VERSION::STRING
+  spec.platform    = Gem::Platform::RUBY
+  spec.authors     = ["Nick Sutterer"]
+  spec.email       = ["apotonick@gmail.com"]
+  spec.homepage    = "https://github.com/apotonick/cells"
+  spec.summary     = %q{View Models for Rails.}
+  spec.description = %q{Cells replace partials and helpers with OOP view models, giving you proper encapsulation, inheritance, testability and a cleaner view architecture.}
+  spec.license     = 'MIT'
 
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
+  spec.files         = `git ls-files`.split("\n")
+  spec.test_files    = `git ls-files -- {test}/*`.split("\n")
+  spec.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  spec.require_paths = ["lib"]
 
-  s.add_dependency "actionpack",  ">= 3.0"
-  s.add_dependency "railties",    ">= 3.0"
-  s.add_dependency "uber",        "~> 0.0.8"
-
-  s.add_development_dependency "rake"
-  s.add_development_dependency "haml"
-  s.add_development_dependency "slim"
-  s.add_development_dependency "tzinfo" # FIXME: why the hell do we need this for 3.1?
-  s.add_development_dependency "minitest",	">= 4.7.5"
-  s.add_development_dependency "activemodel"
-  s.add_development_dependency "capybara"
-  s.add_development_dependency "sprockets"
-  s.add_development_dependency "disposable", "~> 0.0.6"
+  spec.add_dependency 'actionpack',  '>= 3.2'
+  spec.add_dependency "uber",        "~> 0.0.9"
+  spec.add_dependency 'tilt', '>= 1.4', '< 3'
+  spec.add_dependency 'disposable', '~> 0.0.8'
 end

data/gemfiles/rails3.2.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "minitest-reporters"
+gem "pry-byebug", :platforms => [:mri_20, :mri_21]
+gem "appraisal"
+gem "rake"
+gem "test_xml"
+gem "railties", :github => "rails/rails", :branch => "3-2-stable"
+gem "tzinfo"
+gem "minitest", "4.7.5"
+
+gemspec :path => "../"

data/gemfiles/rails4.0.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "minitest-reporters"
+gem "pry-byebug", :platforms => [:mri_20, :mri_21]
+gem "appraisal"
+gem "rake"
+gem "test_xml"
+gem "railties", "4.0.12"
+gem "activemodel"
+gem "minitest", "4.7.5"
+
+gemspec :path => "../"

data/gemfiles/rails4.1.gemfile

@@ -0,0 +1,15 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "minitest-reporters"
+gem "pry-byebug", :platforms => [:mri_20, :mri_21]
+gem "appraisal"
+gem "rake"
+gem "test_xml"
+
+gem "railties", "~> 4.1.0" #, :github => "rails/rails", :branch => "4-1-stable"
+gem "activemodel", "~> 4.1.0" #, :github => "rails/rails", :branch => "4-1-stable"
+gem "minitest", "~> 5.2"
+
+gemspec :path => "../"

data/gemfiles/rails4.2.gemfile

@@ -0,0 +1,14 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "minitest-reporters"
+gem "pry-byebug", :platforms => [:mri_20, :mri_21]
+gem "appraisal"
+gem "rake"
+gem "test_xml"
+gem "railties", :github => "rails/rails", :branch => "4-2-stable"
+gem "activemodel", :github => "rails/rails", :branch => "4-2-stable"
+gem "minitest", "~> 5.2"
+
+gemspec :path => "../"

data/lib/cell.rb

@@ -1,27 +1,34 @@
+require 'tilt'
+require 'uber/inheritable_attr'
+require 'uber/delegates'
+require 'cell/version'
+require 'active_support/dependencies/autoload'
+
 module Cell
-  module OptionsConstructor
-  private
-    def process_args(options={})
-      if options.is_a?(Hash) # TODO: i don't like this too much.
-        process_options(options)
-      else
-        process_model(options)
-      end
+  extend ActiveSupport::Autoload
 
-      super # Base.
-    end
+  autoload :Concept
+  autoload :TestCase
+  autoload :TestHelper
 
-    # DISCUSS: have 2 classes for that?
+  def self.rails_version
+    Gem::Version.new(ActionPack::VERSION::STRING)
+  end
 
-    def process_options(options)
-      options.each do |k, v|
-        instance_variable_set("@#{k}", v)
-        singleton_class.class_eval { attr_reader k }
-      end
+  class TemplateMissingError < RuntimeError
+    def initialize(base, prefixes, view, engine, formats)
+      super("Template missing: view: `#{view.to_s}.#{engine}` prefixes: #{prefixes.inspect} view_paths:#{base.inspect}")
     end
+  end # Error
+end
 
-    def process_model(model)
-      @model = model
-    end
-  end
-end
+require 'cell/caching'
+require 'cell/caching/notification'
+require 'uber/builder'
+require 'cell/prefixes'
+require 'cell/self_contained'
+require 'cell/layout'
+require 'cell/templates'
+require 'cell/view_model'
+
+require 'cell/railtie'

data/lib/cell/caching.rb

@@ -1,7 +1,6 @@
 require 'active_support/concern'
 require 'active_support/cache'
 require 'uber/options'
-require 'uber/inheritable_attr'
 
 module Cell
   module Caching
@@ -36,8 +35,8 @@ module Cell
         cache_store.delete(key, *args)
       end
 
-
     private
+
       def expand_cache_key(key)
         ::ActiveSupport::Cache.expand_cache_key(key, :cells)
       end
@@ -53,18 +52,20 @@ module Cell
       fetch_from_cache_for(key, options) { super(state, *args) }
     end
 
-    def cache_configured?
-      @cache_configured
+    def cache_store  # we want to use DI to set a cache store in cell/rails.
+      ActionController::Base.cache_store
     end
-    attr_writer :cache_configured
-
-    attr_accessor :cache_store  # we want to use DI to set a cache store in cell/rails.
 
     def cache?(state, *args)
-      cache_configured? and state_cached?(state) and self.class.conditional_procs[state].evaluate(self, *args)
+      perform_caching? and state_cached?(state) and self.class.conditional_procs[state].evaluate(self, *args)
     end
 
   private
+
+    def perform_caching?
+      ActionController::Base.perform_caching
+    end
+
     def fetch_from_cache_for(key, options)
       cache_store.fetch(key, options) do
         yield
@@ -74,18 +75,5 @@ module Cell
     def state_cached?(state)
       self.class.version_procs.has_key?(state)
     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
 end

data/lib/cell/caching/notification.rb

@@ -0,0 +1,15 @@
+module Cell
+  module Caching
+    module Notifications
+      def fetch_from_cache_for(key, options)
+        ActiveSupport::Notifications.instrument('read_fragment.cells', :key => key) do
+          cache_store.fetch(key, options) do
+            ActiveSupport::Notifications.instrument('write_fragment.cells', :key => key) do
+              yield
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cell/concept.rb

@@ -1,19 +1,15 @@
-# TODO: deprecate parent_controller, ViewModel
 class Cell::Concept < Cell::ViewModel
   abstract!
-  self.view_paths = "app/concepts"
+  self.view_paths = ["app/concepts"]
 
   # 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)
+    def class_from_cell_name(name)
+      name.classify.constantize
     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?
+      @controller_path ||= name.sub(/::Cell/, '').underscore
     end
   end
 
@@ -22,65 +18,4 @@ class Cell::Concept < Cell::ViewModel
   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/development.rb

@@ -0,0 +1,11 @@
+module Cell
+  module Development
+    def self.included(base)
+      base.instance_eval do
+        def templates
+          Templates.new
+        end
+      end
+    end
+  end
+end

data/lib/{cells → cell}/engines.rb

@@ -1,4 +1,4 @@
-module Cells
+module Cell
   # Now <tt>Rails::Engine</tt>s can contribute to Cells view paths.
   # By default, any 'app/cells' found inside any Engine is automatically included into Cells view paths.
   #

data/lib/cell/layout.rb

@@ -0,0 +1,20 @@
+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
+
+    module ClassMethods
+      def layout(name)
+        self.layout_name = name
+      end
+    end
+
+    def process_options!(options)
+      options[:layout] ||= self.class.layout_name
+      super
+    end
+  end
+end

data/lib/cell/partial.rb

@@ -0,0 +1,17 @@
+# Allows to render global partials, for example.
+#
+#   render partial: "../views/shared/container"
+module Cell::ViewModel::Partial
+  def process_options!(options)
+    super
+    return unless partial = options[:partial]
+
+    parts     = partial.split("/")
+    view      = parts.pop
+    view      = "_#{view}"
+    view     += ".#{options[:formats].first}" if options[:formats]
+    prefixes  = [parts.join("/")]
+
+    options.merge!(:view => view, :prefixes => prefixes)
+  end
+end

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

@@ -1,6 +1,6 @@
 # TODO: merge into Rails core.
 # TODO: cache _prefixes on class layer.
-module Cell::Base::Prefixes
+module Cell::Prefixes
   extend ActiveSupport::Concern
 
   def _prefixes

data/lib/cell/rails.rb

@@ -1,64 +1,72 @@
-require 'cell/rack'
-
+# These Methods are automatically added to all Controllers and Views when
+# the cells plugin is loaded.
 module Cell
-  class Rails < Rack
-    # When this file is included we can savely assume that a rails environment with caching, etc. is available.
-    include ActionController::RequestForgeryProtection
-
-    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.
-        # since i dunno how to do that we'll have this method in rails for now.
-        # DISCUSS: should this be in Cell::Rails::Caching ?
-        ActionController::Base.cache_store
+  module RailsExtensions
+    module ActionController
+      def cell(name, *args, &block)
+        ViewModel.cell(name, self, *args, &block)
       end
 
-      def expire_cache_key(key, *args)  # FIXME: move to Rails.
-        expire_cache_key_for(key, cache_store ,*args)
+      def concept(name, *args, &block)
+        Concept.cell(name, self, *args, &block)
       end
 
-      # Main entry point for instantiating cells.
+      # # Renders the cell state and returns the content. You may pass options here, too. They will be
+      # # around in @opts.
+      # #
+      # # Example:
+      # #
+      # #   @box = render_cell(:posts, :latest, :user => current_user)
+      # #
+      # # If you need the cell instance before it renders, you can pass a block receiving the cell.
+      # #
+      # # Example:
+      # #
+      # #   @box = render_cell(:comments, :top5) do |cell|
+      # #     cell.markdown! if config.parse_comments?
+      # #   end
+      # def render_cell(name, state, *args, &block)
+      #   ::Cell::Rails.render_cell(name, state, self, *args, &block)
+      # end
 
-      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
+      # # Expires the cached cell state view, similar to ActionController::expire_fragment.
+      # # Usually, this method is used in Sweepers.
+      # # Beside the obvious first two args <tt>cell_name</tt> and <tt>state</tt> you can pass
+      # # in additional cache key <tt>args</tt> and cache store specific <tt>opts</tt>.
+      # #
+      # # Example:
+      # #
+      # #  class ListSweeper < ActionController::Caching::Sweeper
+      # #   observe List, Item
+      # #
+      # #   def after_save(record)
+      # #     expire_cell_state :my_listing, :display_list
+      # #   end
+      # #
+      # # will expire the view for state <tt>:display_list</tt> in the cell <tt>MyListingCell</tt>.
+      # def expire_cell_state(cell_class, state, args={}, opts=nil)
+      #   key = cell_class.state_cache_key(state, args)
+      #   cell_class.expire_cache_key(key, opts)
+      # end
     end
 
+    module ActionView
+      # Returns the cell instance for +name+. You may pass arbitrary options to your
+      # cell.
+      #
+      #   = cell(:song, :title => "Creeping Out Sara").render(:show)
+      def cell(name, *args, &block)
+        controller.cell(name, *args, &block)
+      end
 
-    attr_reader :parent_controller
-    alias_method :controller, :parent_controller
-
-    def initialize(parent_controller, *args)
-      super(parent_controller, *args) # FIXME: huh?
-      @parent_controller = parent_controller
-    end
-
-    def cache_configured?
-      ActionController::Base.send(:cache_configured?) # DISCUSS: why is it private?
-    end
-
-    def cache_store
-      self.class.cache_store  # in Rails, we have a global cache store.
-    end
+      # # See Cells::Rails::ActionController#render_cell.
+      # def render_cell(name, state, *args, &block)
+      #   ::Cell::Rails.render_cell(name, state, controller, *args, &block)
+      # end
 
-    module DSL
-      def cell(name, *args)
-        # TODO: this method should be an instance method everywhere.
-        Base.cell_for(name, parent_controller, *args)
+      def concept(name, *args, &block)
+        controller.concept(name, *args, &block)
       end
     end
-    include DSL
   end
 end
-
-require "cell/rails/view_model" # TODO: remove in 4.0.