alchemy_cms 7.4.10 → 8.0.0.b

data/app/models/alchemy/page/{page_layouts.rb → 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 @@ module Alchemy
         # 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 @@ module Alchemy
           @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 @@ module Alchemy
         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 @@ module Alchemy
           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

data/app/models/alchemy/page/fixed_attributes.rb

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

data/app/models/alchemy/page/page_elements.rb

@@ -81,8 +81,8 @@ module Alchemy
       #
       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
@@ -100,7 +100,7 @@ module Alchemy
       # All names of elements that can actually be placed on current page.
       #
       def available_element_names
-        @_available_element_names ||= available_element_definitions.map { |e| e["name"] }
+        @_available_element_names ||= available_element_definitions.map(&:name)
       end
 
       # Available element definitions excluding nested unique elements.
@@ -109,7 +109,7 @@ module Alchemy
         @_available_elements = if parent
           parents_unique_nested_elements = parent.nested_elements.where(unique: true).pluck(:name)
           available_element_definitions(parent.name).reject do |e|
-            parents_unique_nested_elements.include? e["name"]
+            parents_unique_nested_elements.include?(e.name)
           end
         else
           available_element_definitions
@@ -129,10 +129,9 @@ module Alchemy
       #
       def descendent_element_definitions
         definitions = element_definitions_by_name(element_definition_names)
-        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.select { _1.nestable_elements.any? }.flat_map do |d|
+          element_definitions_by_name(d.nestable_elements)
+        end.uniq(&:name)
       end
 
       # All names of elements that are defined in the page definition.
@@ -145,7 +144,7 @@ module Alchemy
       #     elements: [headline, contactform]
       #
       def element_definition_names
-        definition["elements"] || []
+        definition.elements || []
       end
 
       # Element definitions with given name(s)
@@ -161,7 +160,7 @@ module Alchemy
         if names.to_s == "all"
           Element.definitions
         else
-          Element.definitions.select { |e| names.include? e["name"] }
+          Element.definitions.select { names.include?(_1.name) }
         end
       end
 
@@ -181,7 +180,7 @@ module Alchemy
       # 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
@@ -190,7 +189,7 @@ module Alchemy
       #
       def delete_unique_element_definitions!
         @_available_element_definitions.delete_if do |element|
-          element["unique"] && @_existing_element_names.include?(element["name"])
+          element.unique && @_existing_element_names.include?(element.name)
         end
       end
 
@@ -198,8 +197,8 @@ module Alchemy
       #
       def delete_outnumbered_element_definitions!
         @_available_element_definitions.delete_if do |element|
-          outnumbered = @_existing_element_names.select { |name| name == element["name"] }
-          element["amount"] && outnumbered.count >= element["amount"].to_i
+          outnumbered = @_existing_element_names.select { |name| name == element.name }
+          element.amount && outnumbered.count >= element.amount
         end
       end
     end

data/app/models/alchemy/page/page_naming.rb

@@ -17,8 +17,7 @@ module Alchemy
           presence: true, uniqueness: {scope: [:parent_id], case_sensitive: false, unless: -> { parent_id.nil? }}
         validates :urlname,
           uniqueness: {scope: [:language_id, :layoutpage], if: -> { urlname.present? }, case_sensitive: false},
-          exclusion: {in: RESERVED_URLNAMES},
-          length: {minimum: 3, if: -> { urlname.present? }}
+          exclusion: {in: RESERVED_URLNAMES}
 
         before_save :set_title,
           if: -> { title.blank? }
@@ -74,17 +73,10 @@ module Alchemy
         self[:title] = name
       end
 
-      # Converts the given name into an url friendly string.
+      # Returns the full nested urlname.
       #
-      # Names shorter than 3 will be filled up with dashes,
-      # so it does not collidate with the language code.
-      #
-      def converted_url_name
-        url_name = convert_to_urlname(slug.blank? ? name : slug)
-        url_name.rjust(3, "-")
-      end
-
       def nested_url_name
+        converted_url_name = convert_to_urlname(slug.blank? ? name : slug)
         if parent&.language_root?
           converted_url_name
         else

data/app/models/alchemy/page/page_natures.rb

@@ -13,8 +13,21 @@ module Alchemy
         language.public? && !!public_version&.public?
       end
 
+      # Cache-Control max-age duration in seconds.
+      #
+      # You can set this via the `ALCHEMY_PAGE_CACHE_MAX_AGE` environment variable,
+      # in the `Alchemy.config.page_cache_max_age` configuration option,
+      # or in the pages definition in `config/alchemy/page_layouts.yml` file.
+      #
+      # Defaults to 600 seconds.
       def expiration_time
-        public_until ? public_until - Time.current : nil
+        return 0 unless cache_page?
+
+        if definition.cache.to_s.match?(/\d+/)
+          definition.cache.to_i
+        else
+          Alchemy.config.page_cache.max_age
+        end
       end
 
       def rootpage?
@@ -38,13 +51,13 @@ module Alchemy
       # @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 +93,10 @@ module Alchemy
 
       # 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
         end
         definition
       end
@@ -144,17 +157,9 @@ module Alchemy
       # @returns Boolean
       #
       def cache_page?
-        return false unless caching_enabled?
-
-        page_layout = PageLayout.get(self.page_layout)
-        page_layout["cache"] != false && page_layout["searchresults"] != true
-      end
-
-      private
+        return false if !public? || restricted?
 
-      def caching_enabled?
-        Alchemy::Config.get(:cache_pages) &&
-          Rails.application.config.action_controller.perform_caching
+        definition.cache != false && definition.searchresults != true
       end
     end
   end

data/app/models/alchemy/page/page_scopes.rb

@@ -124,7 +124,7 @@ module Alchemy
         end
 
         def ransackable_scopes(_auth_object)
-          [:published, :contentpages, :from_current_site, :searchables, :layoutpages]
+          [:published, :not_public, :restricted, :contentpages, :from_current_site, :searchables, :layoutpages, :by_page_layout]
         end
       end
     end

data/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"
@@ -44,7 +44,6 @@ require_dependency "alchemy/page/page_elements"
 
 module Alchemy
   class Page < BaseRecord
-    include Alchemy::Hints
     include Alchemy::Logger
     include Alchemy::Taggable
 
@@ -90,7 +89,7 @@ module Alchemy
 
     acts_as_nested_set(dependent: :destroy, scope: [:layoutpage, :language_id])
 
-    stampable stamper_class_name: Alchemy.user_class.name
+    stampable stamper_class_name: Alchemy.user_class_name
 
     belongs_to :language
 
@@ -116,7 +115,7 @@ module Alchemy
     has_many :site_languages, through: :site, source: :languages
     has_many :folded_pages, dependent: :destroy
     has_many :legacy_urls, class_name: "Alchemy::LegacyPageUrl", dependent: :destroy
-    has_many :nodes, class_name: "Alchemy::Node", inverse_of: :page
+    has_many :nodes, class_name: "Alchemy::Node", inverse_of: :page, dependent: :restrict_with_error
     has_many :versions, class_name: "Alchemy::PageVersion", inverse_of: :page, dependent: :destroy
     has_one :draft_version, -> { drafts }, class_name: "Alchemy::PageVersion"
     has_one :public_version, -> { published }, class_name: "Alchemy::PageVersion", autosave: -> { persisted? }
@@ -133,11 +132,6 @@ module Alchemy
     before_create -> { versions.build },
       if: -> { versions.none? }
 
-    before_destroy if: -> { nodes.any? } do
-      errors.add(:nodes, :still_present)
-      throw(:abort)
-    end
-
     before_save :set_language_code,
       if: -> { language.present? }
 
@@ -156,7 +150,7 @@ module Alchemy
     after_update :touch_nodes
 
     # Concerns
-    include PageLayouts
+    include Definitions
     include PageScopes
     include PageNatures
     include PageNaming
@@ -164,6 +158,7 @@ module Alchemy
 
     # site_name accessor
     delegate :name, to: :site, prefix: true, allow_nil: true
+    delegate :has_hint?, :hint, to: :definition
 
     # Class methods
     #
@@ -183,37 +178,10 @@ module Alchemy
         @_url_path_class = klass
       end
 
-      def alchemy_resource_filters
-        [
-          {
-            name: :by_page_layout,
-            values: PageLayout.all.map { |p| [Alchemy.t(p["name"], scope: "page_layout_names"), p["name"]] }
-          },
-          {
-            name: :status,
-            values: %w[published not_public restricted]
-          }
-        ]
-      end
-
       def searchable_alchemy_resource_attributes
         %w[name urlname title]
       end
 
-      # Used to store the current page previewed in the edit page template.
-      # @deprecated Use {Alchemy::Current#preview_page=} instead.
-      def current_preview=(page)
-        Current.preview_page = page
-      end
-      deprecate "current_preview=": :"Alchemy::Current.preview_page=", deprecator: Alchemy::Deprecation
-
-      # Returns the current page previewed in the edit page template.
-      # @deprecated Use {Alchemy::Current#preview_page} instead.
-      def current_preview
-        Current.preview_page
-      end
-      deprecate current_preview: :"Alchemy::Current.preview_page", deprecator: Alchemy::Deprecation
-
       # @return the language root page for given language id.
       # @param language_id [Fixnum]
       #
@@ -265,13 +233,13 @@ module Alchemy
 
         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
 
       def link_target_options
         options = [[Alchemy.t(:default, scope: "link_target_options"), ""]]
-        link_target_options = Config.get(:link_target_options)
+        link_target_options = Alchemy.config.link_target_options
         link_target_options.each do |option|
           # add an underscore to the options to provide the default syntax
           # @link https://developer.mozilla.org/en-US/docs/Web/HTML/Element/a#target
@@ -280,6 +248,11 @@ module Alchemy
         end
         options
       end
+
+      # Allow all string and text attributes to be searchable by Ransack.
+      def ransackable_attributes(_auth_object = nil)
+        searchable_alchemy_resource_attributes + ["updated_at"]
+      end
     end
 
     # Instance methods

data/app/models/alchemy/page_definition.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class PageDefinition
+    include ActiveModel::Model
+    include ActiveModel::Attributes
+    include Alchemy::Hints
+
+    extend ActiveModel::Translation
+
+    attribute :name, :string
+    attribute :elements, default: []
+    attribute :autogenerate, default: []
+    attribute :layoutpage, :boolean, default: false
+    attribute :unique, :boolean, default: false
+    attribute :cache, 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
+    delegate :blank?, to: :name
+
+    class << self
+      # Returns all page layouts.
+      #
+      # They are defined in +config/alchemy/page_layout.yml+ file.
+      #
+      def all
+        @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::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(definition)
+        all
+        @definitions += Array.wrap(definition).map { new(**_1) }
+      end
+
+      # Returns one page definition by given name.
+      #
+      def get(name)
+        return new if name.blank?
+
+        all.detect { _1.name.casecmp(name).zero? }
+      end
+
+      def reset!
+        @definitions = nil
+      end
+
+      # The absolute +page_layouts.yml+ file path
+      # @return [Pathname]
+      def layouts_file_path
+        Rails.root.join("config", "alchemy", "page_layouts.yml")
+      end
+
+      private
+
+      # Reads the layout definitions from +config/alchemy/page_layouts.yml+.
+      #
+      def read_definitions_file
+        if File.exist?(layouts_file_path)
+          Array.wrap(
+            YAML.safe_load(
+              ERB.new(File.read(layouts_file_path)).result,
+              permitted_classes: YAML_PERMITTED_CLASSES,
+              aliases: true
+            ) || []
+          )
+        else
+          raise LoadError, "Could not find page_layouts.yml file! Please run `rails generate alchemy:install`"
+        end
+      end
+    end
+
+    def human_name
+      Alchemy::Page.human_layout_name(name)
+    end
+
+    def attributes
+      super.with_indifferent_access
+    end
+
+    private
+
+    def hint_translation_scope
+      :page_hints
+    end
+  end
+end