Convert PageLayout into ActiveModel

Hashes are weak key value stores, while this warrants
a concrete model with a strong contract.

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/models/alchemy/page.rb

@@ -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/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_layouts.rb

@@ -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
@@ -65,25 +67,16 @@ 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
-        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/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
@@ -83,7 +83,7 @@ def definition
         definition = PageLayout.get(page_layout)
         if definition.nil?
           log_warning "Page definition for `#{page_layout}` not found. Please check `page_layouts.yml` file."
-          return {}
+          return PageLayout.new(name: page_layout)
         end
         definition
       end
@@ -147,7 +147,7 @@ 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.cache != false && page_layout.searchresults != true
       end
 
       private

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

@@ -2,14 +2,46 @@
 
 module Alchemy
   class PageLayout
+    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.
       #
@@ -22,23 +54,17 @@ def all
       # @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
@@ -52,7 +52,7 @@ 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"])
+          layout.name.in?(definition["page_layouts"])
         end
       else
         Alchemy::PageLayout.all

lib/alchemy/engine.rb

@@ -62,18 +62,18 @@ class Engine < Rails::Engine
       end
     end
 
-    initializer "alchemy.watch_definition_changes" do |app|
-      elements_reloader = app.config.file_watcher.new([ElementDefinition.definitions_file_path]) do
+    config.to_prepare do
+      elements_reloader = Rails.application.config.file_watcher.new([ElementDefinition.definitions_file_path]) do
         Rails.logger.info "[#{engine_name}] Reloading Element Definitions."
         ElementDefinition.reset!
       end
-      page_layouts_reloader = app.config.file_watcher.new([PageLayout.layouts_file_path]) do
+      page_layouts_reloader = Rails.application.config.file_watcher.new([PageLayout.layouts_file_path]) do
         Rails.logger.info "[#{engine_name}] Reloading Page Layouts."
         PageLayout.reset!
       end
       [elements_reloader, page_layouts_reloader].each do |reloader|
-        app.reloaders << reloader
-        app.reloader.to_run do
+        Rails.application.reloaders << reloader
+        Rails.application.reloader.to_run do
           reloader.execute_if_updated
         end
       end

lib/alchemy/tasks/usage.rb

@@ -11,7 +11,7 @@ def elements_count_by_name
           .group(:name)
           .order("count DESC, name ASC")
           .map { |e| {"name" => e.name, "count" => e.count} }
-        Alchemy::Element.definitions.reject { |definition| res.map { |e| e["name"] }.include? definition["name"] }.sort_by { |d| d["name"] }.each do |definition|
+        Alchemy::Element.definitions.reject { |definition| res.map { |e| e["name"] }.include?(definition["name"]) }.sort_by { _1["name"] }.each do |definition|
           res << {"name" => definition["name"], "count" => 0}
         end
         res
@@ -23,8 +23,8 @@ def pages_count_by_type
           .group(:page_layout)
           .order("count DESC, page_layout ASC")
           .map { |p| {"page_layout" => p.page_layout, "count" => p.count} }
-        Alchemy::PageLayout.all.reject { |page_layout| res.map { |p| p["page_layout"] }.include? page_layout["name"] }.sort_by { |d| d["name"] }.each do |page_layout|
-          res << {"page_layout" => page_layout["name"], "count" => 0}
+        Alchemy::PageLayout.all.reject { |page_layout| res.map { |p| p["page_layout"] }.include?(page_layout.name) }.sort_by(&:name).each do |page_layout|
+          res << {"page_layout" => page_layout.name, "count" => 0}
         end
         res
       end