Rename PageLayout into PageDefinition

tvdeyen · tvdeyen · commit 5e381900645e · 2025-06-09T16:36:08.000+02:00
Page layout has been the name for the layout partial of
a page type (also misleadingly named a layout, but this is a
much bigger change). Element definitions and ingredient
definitions already exist and the page already has a definition
getter method.

Let's name the duck as it quacks.
diff --git a/app/controllers/alchemy/admin/pages_controller.rb b/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
diff --git a/app/helpers/alchemy/pages_helper.rb b/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
 
diff --git a/app/models/alchemy/page.rb b/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
diff --git a/app/models/alchemy/page/definitions.rb b/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
@@ -64,7 +64,7 @@ def human_layout_name(layout)
         private
 
         def layouts_repository
-          @_layouts_repository ||= PageLayout
+          @_layouts_repository ||= PageDefinition
         end
 
         # Returns true if the given layout is unique and not already taken or it should be hidden.
diff --git a/app/models/alchemy/page/page_natures.rb b/app/models/alchemy/page/page_natures.rb
@@ -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 PageLayout.new(name: page_layout)
+          return PageDefinition.new(name: page_layout)
         end
         definition
       end
@@ -146,7 +146,7 @@ def last_modified_at
       def cache_page?
         return false unless caching_enabled?
 
-        page_layout = PageLayout.get(self.page_layout)
+        page_layout = PageDefinition.get(self.page_layout)
         page_layout.cache != false && page_layout.searchresults != true
       end
 
diff --git a/app/models/alchemy/page_definition.rb b/app/models/alchemy/page_definition.rb
@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module Alchemy
-  class PageLayout
+  class PageDefinition
     include ActiveModel::Model
     include ActiveModel::Attributes
 
@@ -49,7 +49,7 @@ def map(...)
       #
       # === 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.
diff --git a/app/models/alchemy/site/layout.rb b/app/models/alchemy/site/layout.rb
@@ -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|
+        Alchemy::PageDefinition.all.select do |layout|
           layout.name.in?(definition["page_layouts"])
         end
       else
-        Alchemy::PageLayout.all
+        Alchemy::PageDefinition.all
       end
     end
 
diff --git a/app/views/alchemy/admin/languages/_form.html.erb b/app/views/alchemy/admin/languages/_form.html.erb
@@ -12,7 +12,7 @@
   <% end %>
   <%= f.input :frontpage_name %>
   <%= f.input :page_layout,
-    collection: Alchemy::PageLayout.all,
+    collection: Alchemy::PageDefinition.all,
     label_method: ->(p) { Alchemy::Page.human_layout_name(p['name']) },
     value_method: ->(p) { p['name'] },
     input_html: {is: 'alchemy-select'} %>
diff --git a/config/alchemy/config.yml b/config/alchemy/config.yml
@@ -13,7 +13,7 @@ auto_logout_time: 30
 #
 # Enable/Disable page caching globally.
 #
-# NOTE: You can enable/disable page caching for single Alchemy::PageLayouts in the page_layout.yml file.
+# NOTE: You can enable/disable page caching for single Alchemy::Definitions in the page_layout.yml file.
 #
 cache_pages: true
 
@@ -110,7 +110,7 @@ default_language:
 #
 # ==== Options:
 #
-#   page_layout_name:           [String] # A +Alchemy::PageLayout+ name. Used to render the contactform on a page with this layout.
+#   page_layout_name:           [String] # A +Alchemy::PageDefinition+ name. Used to render the contactform on a page with this layout.
 #   fields:                     [Array]  # An Array of fieldnames.
 #   validate_fields:            [Array]  # An Array of fieldnames to be validated on presence.
 #
diff --git a/lib/alchemy/cache_digests/template_tracker.rb b/lib/alchemy/cache_digests/template_tracker.rb
@@ -14,15 +14,12 @@ def initialize(name, template)
       def dependencies
         case @name.to_s
         when /^alchemy\/pages\/show/
-          PageLayout.all.map { |p| "alchemy/page_layouts/_#{p["name"]}" }
+          PageDefinition.all.map { "alchemy/page_layouts/_#{_1.name}" }
         when /^alchemy\/page_layouts\/_(\w+)/
-          page_layout = PageLayout.get($1)
-          layout_elements = page_layout.fetch("elements", [])
-          layout_elements.map { |name| "alchemy/elements/_#{name}" }
+          page_definition = PageDefinition.get($1)
+          page_definition.elements.map { "alchemy/elements/_#{_1}" }
         when /^alchemy\/elements\/_(\w+)/
-          ingredient_types($1).map { |type|
-            "alchemy/ingredients/_#{type.underscore}_view"
-          }.uniq
+          ingredient_types($1).map { "alchemy/ingredients/_#{_1.underscore}_view" }.tap(&:uniq!)
         else
           ActionView::DependencyTracker::ERBTracker.call(@name, @template)
         end
@@ -31,10 +28,10 @@ def dependencies
       private
 
       def ingredient_types(name)
-        element = Element.definitions.detect { |e| e["name"] == name }
+        element = Element.definitions.detect { _1["name"] == name }
         return [] unless element
 
-        element.fetch("ingredients", []).collect { |c| c["type"] }
+        element.fetch("ingredients", []).map { _1["type"] }
       end
     end
   end
diff --git a/lib/alchemy/configurations/main.rb b/lib/alchemy/configurations/main.rb
@@ -27,7 +27,7 @@ class Main < Alchemy::Configuration
       #
       # Enable/Disable page caching globally.
       #
-      # NOTE: You can enable/disable page caching for single Alchemy::PageLayouts in the page_layout.yml file.
+      # NOTE: You can enable/disable page caching for single Alchemy::Definitions in the page_layout.yml file.
       #
       option :cache_pages, :boolean, default: true
 
@@ -120,7 +120,7 @@ class Main < Alchemy::Configuration
       #
       # ==== Options:
       #
-      #   page_layout_name:           [String] # A +Alchemy::PageLayout+ name. Used to render the contactform on a page with this layout.
+      #   page_layout_name:           [String] # A +Alchemy::PageDefinition+ name. Used to render the contactform on a page with this layout.
       #   fields:                     [Array]  # An Array of fieldnames.
       #   validate_fields:            [Array]  # An Array of fieldnames to be validated on presence.
       #
diff --git a/lib/alchemy/engine.rb b/lib/alchemy/engine.rb
@@ -67,9 +67,9 @@ class Engine < Rails::Engine
         Rails.logger.info "[#{engine_name}] Reloading Element Definitions."
         ElementDefinition.reset!
       end
-      page_layouts_reloader = Rails.application.config.file_watcher.new([PageLayout.layouts_file_path]) do
+      page_layouts_reloader = Rails.application.config.file_watcher.new([PageDefinition.layouts_file_path]) do
         Rails.logger.info "[#{engine_name}] Reloading Page Layouts."
-        PageLayout.reset!
+        PageDefinition.reset!
       end
       [elements_reloader, page_layouts_reloader].each do |reloader|
         Rails.application.reloaders << reloader
diff --git a/lib/alchemy/on_page_layout.rb b/lib/alchemy/on_page_layout.rb
@@ -9,7 +9,7 @@ module Alchemy
   # Pass a block or method name in which you have the +@page+ object available and can do
   # everything as if you were in a normal controller action.
   #
-  # You can pass a +Alchemy::PageLayout+ name, an array of names, or +:all+ to
+  # You can pass a +Alchemy::PageDefinition+ name, an array of names, or +:all+ to
   # evaluate the callback on either some specific or all the pages.
   #
   # == Example:
@@ -56,7 +56,7 @@ def self.register_callback(page_layout, callback)
     # Pass a block or method name in which you have the +@page+ object available and can do
     # everything as if you were in a normal controller action.
     #
-    # Pass a +Alchemy::PageLayout+ name, an array of names, or +:all+ to
+    # Pass a +Alchemy::PageDefinition+ name, an array of names, or +:all+ to
     # evaluate the callback on either some specific or all the pages.
     #
     def on_page_layout(page_layouts, callback = nil, &block)
diff --git a/lib/alchemy/tasks/usage.rb b/lib/alchemy/tasks/usage.rb
@@ -23,7 +23,7 @@ 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(&:name).each do |page_layout|
+        Alchemy::PageDefinition.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
diff --git a/lib/generators/alchemy/install/templates/alchemy.rb.tt b/lib/generators/alchemy/install/templates/alchemy.rb.tt
@@ -15,7 +15,7 @@ Alchemy.configure do |config|
   #
   # Enable/Disable page caching globally.
   #
-  # NOTE: You can enable/disable page caching for single Alchemy::PageLayouts in the page_layout.yml file.
+  # NOTE: You can enable/disable page caching for single Alchemy::Definitions in the page_layout.yml file.
   #
   # config.cache_pages = <%= default_config.cache_pages.inspect %>
 
@@ -115,7 +115,7 @@ Alchemy.configure do |config|
   #
   # ==== Options:
   #
-  #   page_layout_name:           [String] # A +Alchemy::PageLayout+ name. Used to render the contactform on a page with this layout.
+  #   page_layout_name:           [String] # A +Alchemy::PageDefinition+ name. Used to render the contactform on a page with this layout.
   #   fields:                     [Array]  # An Array of fieldnames.
   #   validate_fields:            [Array]  # An Array of fieldnames to be validated on presence.
   #
diff --git a/spec/controllers/alchemy/admin/elements_controller_spec.rb b/spec/controllers/alchemy/admin/elements_controller_spec.rb
@@ -112,8 +112,8 @@ module Alchemy
 
         context "on a page with a setting for insert_elements_at of top" do
           before do
-            expect(PageLayout).to receive(:get).at_least(:once) do
-              PageLayout.new(
+            expect(PageDefinition).to receive(:get).at_least(:once) do
+              PageDefinition.new(
                 name: "news",
                 elements: ["news"],
                 insert_elements_at: "top"
diff --git a/spec/libraries/template_tracker_spec.rb b/spec/libraries/template_tracker_spec.rb
@@ -10,7 +10,15 @@ module CacheDigests
       describe "#dependencies" do
         context "with alchemy/pages/show given as template name" do
           let(:name) { "alchemy/pages/show" }
-          before { allow(PageLayout).to receive(:all).and_return([{"name" => "intro"}, {"name" => "contact"}]) }
+
+          before do
+            allow(PageDefinition).to receive(:all) do
+              [
+                PageDefinition.new(name: "intro"),
+                PageDefinition.new(name: "contact")
+              ]
+            end
+          end
 
           it "returns all page layout view partial names" do
             is_expected.to include("alchemy/page_layouts/_intro", "alchemy/page_layouts/_contact")
@@ -19,8 +27,9 @@ module CacheDigests
 
         context "with a page layout given as template name" do
           let(:name) { "alchemy/page_layouts/_intro" }
-          let(:page_layout) { {"name" => "intro", "elements" => ["text"]} }
-          before { allow(PageLayout).to receive(:get).and_return(page_layout) }
+          let(:page_layout) { PageDefinition.new(name: "intro", elements: ["text"]) }
+
+          before { allow(PageDefinition).to receive(:get).and_return(page_layout) }
 
           it "returns all element layout view partial names for that layout" do
             is_expected.to include("alchemy/elements/_text")
diff --git a/spec/models/alchemy/admin/filters/select_spec.rb b/spec/models/alchemy/admin/filters/select_spec.rb
@@ -5,7 +5,7 @@
 RSpec.describe Alchemy::Admin::Filters::Select do
   let(:name) { "by_page_layout" }
   let(:resource_name) { "page" }
-  let(:options) { Alchemy::PageLayout.all.map { |p| [Alchemy.t(p["name"], scope: "page_layout_names"), p["name"]] } }
+  let(:options) { Alchemy::PageDefinition.all.map { |p| [Alchemy.t(p["name"], scope: "page_layout_names"), p["name"]] } }
 
   let(:checkbox) { described_class.new(name:, resource_name:, options:) }
 
@@ -43,7 +43,7 @@
 
     context "when the options are given as a nested array" do
       let(:options) do
-        ->(_) { Alchemy::PageLayout.all.map { |p| [Alchemy.t(p["name"], scope: "page_layout_names"), p["name"]] } }
+        ->(_) { Alchemy::PageDefinition.all.map { |p| [Alchemy.t(p["name"], scope: "page_layout_names"), p["name"]] } }
       end
 
       it "returns a select filter input component with given options" do
diff --git a/spec/models/alchemy/page/definitions_spec.rb b/spec/models/alchemy/page/definitions_spec.rb
@@ -2,7 +2,7 @@
 
 require "rails_helper"
 
-RSpec.describe Alchemy::Page::PageLayouts do
+RSpec.describe Alchemy::Page::Definitions do
   describe ".selectable_layouts" do
     let(:site) { create(:alchemy_site) }
     let!(:language) { create(:alchemy_language, code: :de) }
@@ -18,7 +18,7 @@
 
     context "with already taken layouts" do
       before do
-        allow(Alchemy::PageLayout).to receive(:all).and_return([Alchemy::PageLayout.new(unique: true)])
+        allow(Alchemy::PageDefinition).to receive(:all).and_return([Alchemy::PageDefinition.new(unique: true)])
         allow(Alchemy::Page).to receive(:where).and_return double(pluck: [1])
       end
 
diff --git a/spec/models/alchemy/page/fixed_attributes_spec.rb b/spec/models/alchemy/page/fixed_attributes_spec.rb
@@ -6,7 +6,7 @@
   let(:page) { Alchemy::Page.new(page_layout: "foo") }
 
   let(:definition_with_fixed_attributes) do
-    Alchemy::PageLayout.new(
+    Alchemy::PageDefinition.new(
       name: "foo",
       fixed_attributes: {
         name: "Home"
@@ -15,7 +15,7 @@
   end
 
   let(:definition_without_fixed_attributes) do
-    Alchemy::PageLayout.new(name: "foo")
+    Alchemy::PageDefinition.new(name: "foo")
   end
 
   describe "#all" do
diff --git a/spec/models/alchemy/page_definition_spec.rb b/spec/models/alchemy/page_definition_spec.rb
diff --git a/spec/models/alchemy/page_spec.rb b/spec/models/alchemy/page_spec.rb
diff --git a/spec/models/alchemy/site_spec.rb b/spec/models/alchemy/site_spec.rb

Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`# frozen_string_literal: true`
`2`	`2`
`3`	`3`	`module Alchemy`
`4`		`- class PageLayout`
	`4`	`+ class PageDefinition`
`5`	`5`	`include ActiveModel::Model`
`6`	`6`	`include ActiveModel::Attributes`
`7`	`7`
`@@ -49,7 +49,7 @@ def map(...)`
`49`	`49`	`#`
`50`	`50`	`# === Usage Example`
`51`	`51`	`#`
`52`		`- # Call +Alchemy::PageLayout.add(your_definition)+ in your engine.rb file.`
	`52`	`+ # Call +Alchemy::PageDefinition.add(your_definition)+ in your engine.rb file.`
`53`	`53`	`#`
`54`	`54`	`# @param [Array \|\| Hash]`
`55`	`55`	`# You can pass a single layout definition as Hash, or a collection of page layouts as Array.`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ auto_logout_time: 30`
`13`	`13`	`#`
`14`	`14`	`# Enable/Disable page caching globally.`
`15`	`15`	`#`
`16`		`-# NOTE: You can enable/disable page caching for single Alchemy::PageLayouts in the page_layout.yml file.`
	`16`	`+# NOTE: You can enable/disable page caching for single Alchemy::Definitions in the page_layout.yml file.`
`17`	`17`	`#`
`18`	`18`	`cache_pages: true`
`19`	`19`
`@@ -110,7 +110,7 @@ default_language:`
`110`	`110`	`#`
`111`	`111`	`# ==== Options:`
`112`	`112`	`#`
`113`		`-# page_layout_name: [String] # A +Alchemy::PageLayout+ name. Used to render the contactform on a page with this layout.`
	`113`	`+# page_layout_name: [String] # A +Alchemy::PageDefinition+ name. Used to render the contactform on a page with this layout.`
`114`	`114`	`# fields: [Array] # An Array of fieldnames.`
`115`	`115`	`# validate_fields: [Array] # An Array of fieldnames to be validated on presence.`
`116`	`116`	`#`