cadmus 0.6.0 → 0.7.0

data/lib/cadmus/concerns/liquid_template_field.rb

@@ -0,0 +1,33 @@
+module Cadmus
+  module Concerns
+    module LiquidTemplateField
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def liquid_template_field(method_name, field_name)
+          define_method method_name do
+            content = send(field_name)
+
+            begin
+              Liquid::Template.parse(content)
+            rescue Exception => exception
+              Liquid::Template.parse("#{exception.class.name}: #{exception.message}")
+            end
+          end
+        end
+
+        def validates_template_validity(field_name)
+          validate do |model|
+            content = model.send(field_name)
+
+            begin
+              Liquid::Template.parse(content)
+            rescue Exception => exception
+              model.errors.add(field_name, "failed to parse: #{exception.class.name}: #{exception.message}")
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/cadmus/concerns/model_with_parent.rb

@@ -0,0 +1,14 @@
+module Cadmus
+  module Concerns
+    module ModelWithParent
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        def model_with_parent
+          belongs_to :parent, polymorphic: true, optional: true
+          scope :global, -> { where(:parent_id => nil, :parent_type => nil) }
+        end
+      end
+    end
+  end
+end

data/lib/cadmus/concerns/other_class_accessor.rb

@@ -0,0 +1,50 @@
+module Cadmus
+  module Concerns
+    module OtherClassAccessor
+      # Defines an accessor method for a field that stores a class.  Simply storing the class can mess up Rails
+      # reloading, so behind the scenes, this stores the name of the class and then, when something tries to get the
+      # value of the field, safe_constantizes that name and memoizes the result.
+      #
+      # When using this in a gem, it's important to call the clear_<field name>_cache! method in the engine's
+      # to_prepare block, e.g.:
+      #
+      #    config.to_prepare do
+      #      Cadmus::PartialFileSystem.clear_partial_model_cache!
+      #    end
+      def other_class_accessor(field_name)
+        name_ivar = "@_#{field_name}_name"
+        class_memo_ivar = "@_#{field_name}"
+
+        # getter method
+        define_singleton_method field_name do
+          memoized_class = instance_variable_get(class_memo_ivar)
+
+          unless memoized_class
+            name = instance_variable_get(name_ivar)
+            return unless name
+
+            memoized_class = name.safe_constantize
+            instance_variable_set(class_memo_ivar, memoized_class)
+          end
+
+          memoized_class
+        end
+
+        # setter method
+        define_singleton_method "#{field_name}=" do |klass|
+          class_name = case klass
+          when Class then klass.name
+          else klass
+          end
+
+          instance_variable_set(name_ivar, class_name)
+        end
+
+        # clear memoized class method
+        define_singleton_method "clear_#{field_name}_cache!" do
+          instance_variable_set(class_memo_ivar, nil)
+        end
+      end
+    end
+  end
+end

data/lib/cadmus/engine.rb

@@ -0,0 +1,9 @@
+module Cadmus
+  class Engine < Rails::Engine
+    config.to_prepare do
+      Cadmus.clear_layout_model_cache!
+      Cadmus.clear_page_model_cache!
+      Cadmus.clear_partial_model_cache!
+    end
+  end
+end

data/lib/cadmus/layout.rb

@@ -0,0 +1,32 @@
+module Cadmus
+  module Layout
+    extend ActiveSupport::Concern
+    include Cadmus::Concerns::LiquidTemplateField
+    include Cadmus::Concerns::ModelWithParent
+
+    module ClassMethods
+      # Sets up a model to behave as a Cadmus layout.  This will add the following behaviors:
+      #
+      # * A name field that determines the name of the layout for administrative UI
+      # * An optional, polymorphic +parent+ field
+      # * A scope called +global+ that returns instances of this class that have no parent
+      # * A +liquid_template+ method that parses the value of this model's +content+ field as a Liquid
+      #   template
+      # * A validator that ensure that this layout has a name
+      #
+      # @param options [Hash] options to modify the default behavior
+      # @option options :name_field the name of the field to be used as the layout name.  Defaults to +:name+.
+      # @option options :skip_template_validation if present, skips the validation of the content template.
+      def cadmus_layout(options = {})
+        model_with_parent
+
+        cattr_accessor :name_field
+        self.name_field = (options.delete(:name_field) || :name).to_s
+        validates_uniqueness_of name_field, scope: [:parent_id, :parent_type]
+
+        liquid_template_field :liquid_template, :content
+        validates_template_validity :content unless options[:skip_template_validation]
+      end
+    end
+  end
+end

data/lib/cadmus/layouts_controller.rb

@@ -0,0 +1,70 @@
+module Cadmus
+  module LayoutsController
+    extend ActiveSupport::Concern
+    include Cadmus::Concerns::ControllerWithParent
+
+    included do
+      before_action :load_parent_and_cms_layout
+    end
+
+    def index
+      @cms_layouts = cms_layout_scope.order(cms_layout_scope.klass.name_field).all
+      render 'cadmus/layouts/index'
+    end
+
+    def new
+      @cms_layout = cms_layout_scope.new
+      render 'cadmus/layouts/new'
+    end
+
+    def edit
+      render 'cadmus/layouts/edit'
+    end
+
+    def create
+      @cms_layout = cms_layout_scope.new(cms_layout_params)
+
+      if @cms_layout.save
+        redirect_to(url_for(action: 'index'))
+      else
+        render 'cadmus/layouts/new'
+      end
+    end
+
+    def update
+      if @cms_layout.update_attributes(cms_layout_params)
+        redirect_to(url_for(action: 'index'))
+      else
+        render 'cadmus/layouts/edit'
+      end
+    end
+
+    def destroy
+      @cms_layout.destroy
+      redirect_to(url_for(action: 'index'))
+    end
+
+    protected
+
+    # Returns the ActiveRecord::Relation that will be used for finding layouts.  If there is a parent
+    # for this request, this will be the "cms_layouts" scope defined by the parent object.  If there isn't,
+    # this will be the "global" scope of the layout class (i.e. layouts with no parent object).
+    def cms_layout_scope
+      @cms_layout_scope ||= parent_model ? parent_model.cms_layouts : cms_layout_model.global
+    end
+
+    def cms_layout_model
+      Cadmus.layout_model
+    end
+
+    def cms_layout_params
+      params.require(:cms_layout).permit(:name, :content)
+    end
+
+    def load_parent_and_cms_layout
+      if params[:id]
+        @cms_layout = cms_layout_scope.find(params[:id])
+      end
+    end
+  end
+end

data/lib/cadmus/page.rb

@@ -1,12 +1,11 @@
-require 'liquid'
-
 module Cadmus
 
   # Adds a +cadmus_page+ extension method to ActiveRecord::Base that sets up a class as a page-like object for
   # Cadmus.
   module Page
     extend ActiveSupport::Concern
-    include Cadmus::LiquidTemplateField
+    include Cadmus::Concerns::LiquidTemplateField
+    include Cadmus::Concerns::ModelWithParent
 
     module ClassMethods
 
@@ -26,6 +25,8 @@ module Cadmus
       # @option options :slug_field the name of the field to be used as the page slug.  Defaults to +:slug+.
       # @option options :slug_generator_field the name of the field to be used as the slug generator.
       #   Defaults to the value of +name_field+ if unspecified.
+      # @option options :layout_model_name the name of the model to use as a layout for this page class.
+      # @option options :skip_template_validation if present, skips the validation of the content template.
       def cadmus_page(options={})
         options[:slug_generator_field] = options[:name_field] unless options.has_key?(:slug_generator_field)
         has_slug(options)
@@ -33,18 +34,32 @@ module Cadmus
         cattr_accessor :name_field
         self.name_field = (options.delete(:name_field) || :name).to_s
 
-        belongs_to :parent, :polymorphic => true
+        model_with_parent
 
         validates_presence_of name_field
         validates_uniqueness_of slug_field, :scope => [:parent_id, :parent_type]
         validates_exclusion_of slug_field, :in => %w(pages edit)
 
-        scope :global, lambda { where(:parent_id => nil, :parent_type => nil) }
+        cattr_accessor :layout_model_name
+        self.layout_model_name = options.delete(:layout_model_name) || Cadmus.layout_model.try!(:name)
+
+        if layout_model
+          belongs_to :cms_layout, class_name: layout_model.name, optional: true
+        end
 
         liquid_template_field :liquid_template, :content
+        validates_template_validity :content unless options[:skip_template_validation]
+      end
+
+      def layout_model
+        return unless layout_model_name
+        layout_model_name.safe_constantize
       end
     end
+
+    def effective_cms_layout
+      return nil unless respond_to?(:cms_layout)
+      cms_layout
+    end
   end
 end
-
-ActiveRecord::Base.send :include, Cadmus::Page

data/lib/cadmus/{controller_extensions.rb → pages_controller.rb}

@@ -65,12 +65,9 @@ module Cadmus
   module PagesController
     extend ActiveSupport::Concern
     include Cadmus::Renderable
+    include Cadmus::Concerns::ControllerWithParent
 
     included do
-      class << self
-        attr_accessor :page_parent_name, :page_parent_class, :find_parent_by
-      end
-
       before_action :load_parent_and_page
       helper_method :cadmus_renderer
     end
@@ -151,64 +148,15 @@ module Cadmus
 
     protected
 
-    # This gets kind of meta.
-    #
-    # If page_parent_name and page_parent_class are both defined for this class, this method uses it to find
-    # the parent object in which pages live.  For example, if page_parent_class is Blog and page_parent_name
-    # is "blog", then this is equivalent to calling:
-    #
-    #     @page_parent = Blog.where(:id => params["blog_id"]).first
-    #
-    # If you don't want to use :id to find the parent object, then redefine the find_parent_by method to return
-    # what you want to use.
-    def page_parent
-      return @page_parent if @page_parent
-
-      if page_parent_name && page_parent_class
-        parent_id_param = "#{page_parent_name}_id"
-        if params[parent_id_param]
-          @page_parent = page_parent_class.where(find_parent_by => params[parent_id_param]).first
-        end
-      end
-
-      @page_parent
-    end
-
-    # Returns the name of the page parent object.  This will be used for determining the parameter name for
-    # finding the parent object.  For example, if the page parent name is "wiki", the finder will look in
-    # params["wiki_id"] to determine the object ID.
-    #
-    # By default, this will return the value of page_parent_name set at the controller class level, but can
-    # be overridden for cases where the page parent name must be determined on a per-request basis.
-    def page_parent_name
-      self.class.page_parent_name
-    end
-
-    # Returns the class of the page parent object.  For example, if the pages used by this controller are
-    # children of a Section object, this method should return the Section class.
-    #
-    # By default, this will return the value of page_parent_class set at the controller class level, but can
-    # be overridden for cases where the page parent class must be determined on a per-request basis.
-    def page_parent_class
-      self.class.page_parent_class
-    end
-
-    # Returns the field used to find the page parent object.  By default this is :id, but if you need to
-    # find the page parent object using a different parameter (for example, if you use a "slug" field for
-    # part of the URL), this can be changed.
-    #
-    # By default this method takes its value from the "find_parent_by" accessor set at the controller class
-    # level, but it can be overridden for cases where the finder field name should be determined on a
-    # per-request basis.
-    def find_parent_by
-      self.class.find_parent_by || :id
-    end
-
     # Returns the ActiveRecord::Relation that will be used for finding pages.  If there is a page parent
     # for this request, this will be the "pages" scope defined by the parent object.  If there isn't,
     # this will be the "global" scope of the page class (i.e. pages with no parent object).
     def page_scope
-      @page_scope ||= page_parent ? page_parent.pages : page_class.global
+      @page_scope ||= parent_model ? parent_model.pages : page_class.global
+    end
+
+    def page_class
+      Cadmus.page_model
     end
 
     def page_params
@@ -223,7 +171,7 @@ module Cadmus
     end
 
     def liquid_registers
-      registers = { 'parent' => page_parent }
+      registers = { 'parent' => parent_model, :file_system => liquid_file_system }
 
       if defined?(super)
         registers.merge(super)
@@ -232,4 +180,4 @@ module Cadmus
       end
     end
   end
-end
+end

data/lib/cadmus/partial.rb

@@ -0,0 +1,32 @@
+module Cadmus
+  module Partial
+    extend ActiveSupport::Concern
+    include Cadmus::Concerns::LiquidTemplateField
+    include Cadmus::Concerns::ModelWithParent
+
+    module ClassMethods
+      # Sets up a model to behave as a Cadmus partial.  This will add the following behaviors:
+      #
+      # * A name field that determines the name of the partial for administrative UI
+      # * An optional, polymorphic +parent+ field
+      # * A scope called +global+ that returns instances of this class that have no parent
+      # * A +liquid_template+ method that parses the value of this model's +content+ field as a Liquid
+      #   template
+      # * A validator that ensure that this layout has a name
+      #
+      # @param options [Hash] options to modify the default behavior
+      # @option options :name_field the name of the field to be used as the layout name.  Defaults to +:name+.
+      # @option options :skip_template_validation if present, skips the validation of the content template.
+      def cadmus_partial(options = {})
+        model_with_parent
+
+        cattr_accessor :name_field
+        self.name_field = (options.delete(:name_field) || :name).to_s
+        validates_uniqueness_of name_field, scope: [:parent_id, :parent_type]
+
+        liquid_template_field :liquid_template, :content
+        validates_template_validity :content unless options[:skip_template_validation]
+      end
+    end
+  end
+end

data/lib/cadmus/partial_file_system.rb

@@ -0,0 +1,28 @@
+module Cadmus
+  # An implementation of Liquid's FileSystem interface that lets it read partials from a model that includes Cadmus::Partial
+  class PartialFileSystem
+    def initialize(parent)
+      @parent = parent
+    end
+
+    def read_template_file(template_path)
+      partial_scope.find_by!(partial_model.name_field => template_path).content
+    end
+
+    private
+
+    def partial_model
+      Cadmus.partial_model
+    end
+
+    def partial_scope
+      if @parent
+        partial_model.where(parent: @parent)
+      else
+        partial_model.global
+      end
+    end
+  end
+end
+
+Liquid::Template.file_system = Cadmus::PartialFileSystem.new(nil)

data/lib/cadmus/partials_controller.rb

@@ -0,0 +1,70 @@
+module Cadmus
+  module PartialsController
+    extend ActiveSupport::Concern
+    include Cadmus::Concerns::ControllerWithParent
+
+    included do
+      before_action :load_parent_and_cms_partial
+    end
+
+    def index
+      @cms_partials = cms_partial_scope.order(cms_partial_class.name_field).all
+      render 'cadmus/partials/index'
+    end
+
+    def new
+      @cms_partial = cms_partial_scope.new
+      render 'cadmus/partials/new'
+    end
+
+    def edit
+      render 'cadmus/partials/edit'
+    end
+
+    def create
+      @cms_partial = cms_partial_scope.new(cms_partial_params)
+
+      if @cms_partial.save
+        redirect_to(url_for(action: 'index'))
+      else
+        render 'cadmus/partials/new'
+      end
+    end
+
+    def update
+      if @cms_partial.update_attributes(cms_partial_params)
+        redirect_to(url_for(action: 'index'))
+      else
+        render 'cadmus/partials/edit'
+      end
+    end
+
+    def destroy
+      @cms_partial.destroy
+      redirect_to(url_for(action: 'index'))
+    end
+
+    protected
+
+    # Returns the ActiveRecord::Relation that will be used for finding partials.  If there is a parent
+    # for this request, this will be the "cms_partials" scope defined by the parent object.  If there isn't,
+    # this will be the "global" scope of the partial class (i.e. partials with no parent object).
+    def cms_partial_scope
+      @cms_partial_scope ||= parent_model ? parent_model.cms_partials : cms_partial_class.global
+    end
+
+    def cms_partial_class
+      Cadmus.partial_model
+    end
+
+    def cms_partial_params
+      params.require(:cms_partial).permit(cms_partial_class.name_field, :content)
+    end
+
+    def load_parent_and_cms_partial
+      if params[:id]
+        @cms_partial = cms_partial_scope.find(params[:id])
+      end
+    end
+  end
+end