Merge pull request #3263 from AlchemyCMS/page-layout-model

Convert PageLayout into ActiveModel

Author: tvdeyen

app/controllers/alchemy/admin/elements_controller.rb

@@ -35,7 +35,7 @@ def create
           else
             Element.new(create_element_params)
           end
-          if @page.definition["insert_elements_at"] == "top"
+          if @page.definition.insert_elements_at == "top"
             @insert_at_top = true
             @element.position = 1
           end

app/controllers/alchemy/admin/pages_controller.rb

@@ -38,7 +38,7 @@ class PagesController < ResourcesController
         only: [:show]
 
       add_alchemy_filter :by_page_layout, type: :select, options: ->(_q) do
-        PageLayout.all.map { |p| [Alchemy.t(p[:name], scope: "page_layout_names"), p[:name]] }
+        PageDefinition.all.map { |p| [Alchemy.t(p[:name], scope: "page_layout_names"), p[:name]] }
       end
 
       add_alchemy_filter :updated_at_gteq, type: :datepicker

app/helpers/alchemy/pages_helper.rb

@@ -46,7 +46,7 @@ def language_links(options = {})
     def render_page_layout
       render @page, page: @page
     rescue ActionView::MissingTemplate
-      warning("PageLayout: '#{@page.page_layout}' not found. Rendering standard page_layout.")
+      warning("[alchemy]: '#{@page.page_layout}' page layout not found. Rendering 'standard' page layout.")
       render "alchemy/page_layouts/standard", page: @page
     end
 

app/models/alchemy/page.rb

@@ -36,7 +36,7 @@
 #
 
 require_dependency "alchemy/page/fixed_attributes"
-require_dependency "alchemy/page/page_layouts"
+require_dependency "alchemy/page/definitions"
 require_dependency "alchemy/page/page_scopes"
 require_dependency "alchemy/page/page_natures"
 require_dependency "alchemy/page/page_naming"
@@ -156,7 +156,7 @@ class Page < BaseRecord
     after_update :touch_nodes
 
     # Concerns
-    include PageLayouts
+    include Definitions
     include PageScopes
     include PageNatures
     include PageNaming
@@ -238,7 +238,7 @@ def all_from_clipboard_for_select(clipboard, language_id, layoutpages: false)
 
         clipboard_pages = all_from_clipboard(clipboard)
         allowed_page_layouts = Alchemy::Page.selectable_layouts(language_id, layoutpages: layoutpages)
-        allowed_page_layout_names = allowed_page_layouts.collect { |p| p["name"] }
+        allowed_page_layout_names = allowed_page_layouts.collect(&:name)
         clipboard_pages.select { |cp| allowed_page_layout_names.include?(cp.page_layout) }
       end
 

app/models/alchemy/page/page_layouts.rb app/models/alchemy/page/definitions.rbapp/models/alchemy/page/page_layouts.rb renamed to app/models/alchemy/page/definitions.rb

@@ -4,13 +4,13 @@ module Alchemy
   class Page < BaseRecord
     # Module concerning page layouts
     #
-    module PageLayouts
+    module Definitions
       extend ActiveSupport::Concern
 
       module ClassMethods
         # Register a custom page layouts repository
         #
-        # The default repository is Alchemy::PageLayout
+        # The default repository is Alchemy::PageDefinition
         #
         def layouts_repository=(klass)
           @_layouts_repository = klass
@@ -19,8 +19,10 @@ def layouts_repository=(klass)
         # Returns page layouts ready for Rails' select form helper.
         #
         def layouts_for_select(language_id, layoutpages: false)
-          @map_array = []
-          mapped_layouts_for_select(selectable_layouts(language_id, layoutpages: layoutpages))
+          layouts = selectable_layouts(language_id, layoutpages: layoutpages)
+          layouts.map do |layout|
+            [layout.human_name, layout.name]
+          end
         end
 
         # Returns all layouts that can be used for creating a new page.
@@ -36,9 +38,9 @@ def selectable_layouts(language_id, layoutpages: false)
           @language_id = language_id
           layouts_repository.all.select do |layout|
             if layoutpages
-              layout["layoutpage"] && layout_available?(layout)
+              layout.layoutpage && layout_available?(layout)
             else
-              !layout["layoutpage"] && layout_available?(layout)
+              !layout.layoutpage && layout_available?(layout)
             end
           end
         end
@@ -62,28 +64,19 @@ def human_layout_name(layout)
         private
 
         def layouts_repository
-          @_layouts_repository ||= PageLayout
-        end
-
-        # Maps given layouts for Rails select form helper.
-        #
-        def mapped_layouts_for_select(layouts)
-          layouts.each do |layout|
-            @map_array << [human_layout_name(layout["name"]), layout["name"]]
-          end
-          @map_array
+          @_layouts_repository ||= PageDefinition
         end
 
         # Returns true if the given layout is unique and not already taken or it should be hidden.
         #
         def layout_available?(layout)
-          !layout["hide"] && !already_taken?(layout) && available_on_site?(layout)
+          !layout.hide && !already_taken?(layout) && available_on_site?(layout)
         end
 
         # Returns true if this layout is unique and already taken by another page.
         #
         def already_taken?(layout)
-          layout["unique"] && page_with_layout_existing?(layout["name"])
+          layout.unique && page_with_layout_existing?(layout.name)
         end
 
         # Returns true if one page already has the given layout
@@ -106,7 +99,7 @@ def available_on_site?(layout)
           return false unless Alchemy::Current.site
 
           Alchemy::Current.site.definition.blank? ||
-            Alchemy::Current.site.definition.fetch("page_layouts", []).include?(layout["name"])
+            Alchemy::Current.site.definition.fetch("page_layouts", []).include?(layout.name)
         end
       end
     end

app/models/alchemy/page/fixed_attributes.rb

@@ -31,7 +31,7 @@ def initialize(page)
       # @return Hash
       #
       def attributes
-        @_attributes ||= page.definition.fetch("fixed_attributes", {}).symbolize_keys
+        @_attributes ||= page.definition.fixed_attributes.symbolize_keys
       end
       alias_method :all, :attributes
 

app/models/alchemy/page/page_elements.rb

@@ -81,8 +81,8 @@ def duplicate_elements(elements, repository, page_version)
       #
       def available_element_definitions(only_element_named = nil)
         @_available_element_definitions ||= if only_element_named
-          definition = Element.definition_by_name(only_element_named)
-          element_definitions_by_name(definition["nestable_elements"])
+          element_definition = Element.definition_by_name(only_element_named)
+          element_definitions_by_name(element_definition["nestable_elements"])
         else
           element_definitions.dup
         end
@@ -132,7 +132,7 @@ def descendent_element_definitions
         definitions.select { |d| d.key?("nestable_elements") }.each do |d|
           definitions += element_definitions_by_name(d["nestable_elements"])
         end
-        definitions.uniq { |d| d["name"] }
+        definitions.uniq { _1["name"] }
       end
 
       # All names of elements that are defined in the page definition.
@@ -145,7 +145,7 @@ def descendent_element_definitions
       #     elements: [headline, contactform]
       #
       def element_definition_names
-        definition["elements"] || []
+        definition.elements || []
       end
 
       # Element definitions with given name(s)
@@ -181,7 +181,7 @@ def richtext_ingredients_ids
       # And if so, it generates them.
       #
       def generate_elements
-        definition.fetch("autogenerate", []).each do |element_name|
+        definition.autogenerate&.each do |element_name|
           Element.create(page: self, page_version: draft_version, name: element_name)
         end
       end

app/models/alchemy/page/page_natures.rb

@@ -38,13 +38,13 @@ def folded?(user_id)
       # @returns Array
       #
       def has_limited_editors?
-        definition["editable_by"].present?
+        definition.editable_by.present?
       end
 
       def editor_roles
         return unless has_limited_editors?
 
-        definition["editable_by"]
+        definition.editable_by
       end
 
       # True if page locked_at timestamp and locked_by id are set
@@ -80,10 +80,10 @@ def status_title(status_type)
 
       # Returns the self#page_layout definition from config/alchemy/page_layouts.yml file.
       def definition
-        definition = PageLayout.get(page_layout)
+        definition = PageDefinition.get(page_layout)
         if definition.nil?
           log_warning "Page definition for `#{page_layout}` not found. Please check `page_layouts.yml` file."
-          return {}
+          return PageDefinition.new(name: page_layout)
         end
         definition
       end
@@ -146,8 +146,8 @@ def last_modified_at
       def cache_page?
         return false unless caching_enabled?
 
-        page_layout = PageLayout.get(self.page_layout)
-        page_layout["cache"] != false && page_layout["searchresults"] != true
+        page_layout = PageDefinition.get(self.page_layout)
+        page_layout.cache != false && page_layout.searchresults != true
       end
 
       private

lib/alchemy/page_layout.rb app/models/alchemy/page_definition.rblib/alchemy/page_layout.rb renamed to app/models/alchemy/page_definition.rb

@@ -1,44 +1,70 @@
 # frozen_string_literal: true
 
 module Alchemy
-  class PageLayout
+  class PageDefinition
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+
+    extend ActiveModel::Translation
+
+    attribute :name, :string
+    attribute :elements, default: []
+    attribute :autogenerate, default: []
+    attribute :layoutpage, :boolean, default: false
+    attribute :unique, :boolean, default: false
+    attribute :cache, :boolean, default: true
+    attribute :insert_elements_at, :string, default: "bottom"
+    attribute :fixed_attributes, default: {}
+    attribute :searchable, :boolean, default: true
+    attribute :searchresults, :boolean, default: false
+    attribute :hide, :boolean, default: false
+    attribute :editable_by
+    attribute :hint
+
+    validates :name,
+      presence: true,
+      format: {
+        with: /\A[a-z_-]+\z/
+      }
+
+    delegate :[], to: :attributes
+
     class << self
       # Returns all page layouts.
       #
       # They are defined in +config/alchemy/page_layout.yml+ file.
       #
       def all
-        @definitions ||= read_definitions_file.map(&:with_indifferent_access)
+        @definitions ||= read_definitions_file.map { new(**_1) }
+      end
+
+      def map(...)
+        all.map(...)
       end
+      alias_method :collect, :map
 
       # Add additional page definitions to collection.
       #
       # Useful for extending the page layouts from an Alchemy module.
       #
       # === Usage Example
       #
-      #   Call +Alchemy::PageLayout.add(your_definition)+ in your engine.rb file.
+      #   Call +Alchemy::PageDefinition.add(your_definition)+ in your engine.rb file.
       #
       # @param [Array || Hash]
       #   You can pass a single layout definition as Hash, or a collection of page layouts as Array.
       #
-      def add(page_layout)
+      def add(definition)
         all
-        if page_layout.is_a?(Array)
-          @definitions += page_layout
-        elsif page_layout.is_a?(Hash)
-          @definitions << page_layout
-        else
-          raise TypeError
-        end
+        @definitions += Array.wrap(definition).map { new(**_1) }
       end
 
       # Returns one page definition by given name.
       #
       def get(name)
-        return {} if name.blank?
+        return new if name.blank?
 
-        all.detect { |a| a["name"].casecmp(name).zero? }
+        all.detect { _1.name.casecmp(name).zero? }
       end
 
       def reset!
@@ -69,5 +95,13 @@ def read_definitions_file
         end
       end
     end
+
+    def human_name
+      Alchemy::Page.human_layout_name(name)
+    end
+
+    def attributes
+      super.with_indifferent_access
+    end
   end
 end

app/models/alchemy/site/layout.rb

@@ -41,8 +41,8 @@ def definition
     #
     def page_layout_names(layoutpages: false)
       page_layout_definitions.select do |layout|
-        !!layout["layoutpage"] && layoutpages || !layout["layoutpage"] && !layoutpages
-      end.collect { |layout| layout["name"] }
+        !!layout.layoutpage && layoutpages || !layout.layoutpage && !layoutpages
+      end.tap { _1.collect!(&:name) }
     end
 
     # Returns sites page layout definitions
@@ -51,11 +51,11 @@ def page_layout_names(layoutpages: false)
     #
     def page_layout_definitions
       if definition["page_layouts"].presence
-        Alchemy::PageLayout.all.select do |layout|
-          layout["name"].in?(definition["page_layouts"])
+        Alchemy::PageDefinition.all.select do |layout|
+          layout.name.in?(definition["page_layouts"])
         end
       else
-        Alchemy::PageLayout.all
+        Alchemy::PageDefinition.all
       end
     end