alchemy_cms 8.0.11 → 8.1.0

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

@@ -10,7 +10,7 @@ module Alchemy
         @page = page
       end
 
-      # Copies all currently visible elements to the public version of page
+      # Copies all currently publishable elements to the public version of page
       #
       # Creates a new published version if none exists yet and updates
       # the `published_at` timestamp of the page.
@@ -24,10 +24,12 @@ module Alchemy
             version = public_version(public_on)
             DeleteElements.new(version.elements).call
 
+            copy_metadata(public_version: version)
+
             repository = page.draft_version.element_repository
             ActiveRecord::Base.no_touching do
               Element.acts_as_list_no_update do
-                repository.visible.not_nested.each.with_index(1) do |element, position|
+                repository.publishable.not_nested.each.with_index(1) do |element, position|
                   Alchemy::DuplicateElement.new(element, repository: repository, publishable_only: true).call(
                     page_version_id: version.id,
                     position: position
@@ -51,6 +53,16 @@ module Alchemy
       def public_version(public_on)
         page.public_version || page.versions.create!(public_on: public_on)
       end
+
+      # Copy metadata from draft_version to public_version.
+      def copy_metadata(public_version:)
+        draft = page.draft_version
+        return unless draft
+
+        PageVersion::METADATA_ATTRIBUTES.each do |attr|
+          public_version.send(:"#{attr}=", draft.send(attr))
+        end
+      end
     end
   end
 end

data/app/models/alchemy/page.rb

@@ -7,12 +7,12 @@
 #  id               :integer          not null, primary key
 #  name             :string
 #  urlname          :string
-#  title            :string
+#  title            :string           (deprecated - use draft_version.title)
 #  language_code    :string
 #  language_root    :boolean
 #  page_layout      :string
-#  meta_keywords    :text
-#  meta_description :text
+#  meta_keywords    :text             (deprecated - use draft_version.meta_keywords)
+#  meta_description :text             (deprecated - use draft_version.meta_description)
 #  lft              :integer
 #  rgt              :integer
 #  parent_id        :integer
@@ -44,9 +44,15 @@ require_dependency "alchemy/page/page_elements"
 
 module Alchemy
   class Page < BaseRecord
-    include Alchemy::Logger
     include Alchemy::Taggable
 
+    # These columns are deprecated in favor of page versions
+    self.ignored_columns += [
+      "meta_description",
+      "meta_keywords",
+      "title"
+    ]
+
     DEFAULT_ATTRIBUTES_FOR_COPY = {
       autogenerate_elements: false,
       public_on: nil,
@@ -66,11 +72,12 @@ module Alchemy
       depth
       urlname
       cached_tag_list
+      title
+      meta_description
+      meta_keywords
     ]
 
     PERMITTED_ATTRIBUTES = [
-      :meta_description,
-      :meta_keywords,
       :name,
       :page_layout,
       :public_on,
@@ -81,33 +88,35 @@ module Alchemy
       :searchable,
       :sitemap,
       :tag_list,
-      :title,
       :urlname,
       :layoutpage,
-      :menu_id
+      :menu_id,
+      {
+        draft_version_attributes: [:id] + PageVersion::METADATA_ATTRIBUTES.map(&:to_sym)
+      }
     ]
 
     acts_as_nested_set(dependent: :destroy, scope: [:layoutpage, :language_id])
 
-    stampable stamper_class_name: Alchemy.user_class_name
+    stampable stamper_class_name: Alchemy.config.user_class_name
 
     belongs_to :language
 
     belongs_to :creator,
-      primary_key: Alchemy.user_class_primary_key,
-      class_name: Alchemy.user_class_name,
+      primary_key: Alchemy.config.user_class_primary_key,
+      class_name: Alchemy.config.user_class_name,
       foreign_key: :creator_id,
       optional: true
 
     belongs_to :updater,
-      primary_key: Alchemy.user_class_primary_key,
-      class_name: Alchemy.user_class_name,
+      primary_key: Alchemy.config.user_class_primary_key,
+      class_name: Alchemy.config.user_class_name,
       foreign_key: :updater_id,
       optional: true
 
     belongs_to :locker,
-      primary_key: Alchemy.user_class_primary_key,
-      class_name: Alchemy.user_class_name,
+      primary_key: Alchemy.config.user_class_primary_key,
+      class_name: Alchemy.config.user_class_name,
       foreign_key: :locked_by,
       optional: true
 
@@ -117,8 +126,10 @@ module Alchemy
     has_many :legacy_urls, class_name: "Alchemy::LegacyPageUrl", dependent: :destroy
     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? }
+    has_one :draft_version, -> { draft.order(updated_at: :desc) }, class_name: "Alchemy::PageVersion"
+    has_one :public_version, -> { published.order(public_on: :desc) }, class_name: "Alchemy::PageVersion", autosave: -> { persisted? }
+
+    accepts_nested_attributes_for :draft_version
 
     has_many :page_ingredients, class_name: "Alchemy::Ingredients::Page", foreign_key: :related_object_id, dependent: :nullify
 
@@ -129,8 +140,7 @@ module Alchemy
     validates_format_of :page_layout, with: /\A[a-z0-9_-]+\z/, unless: -> { page_layout.blank? }
     validates_presence_of :parent, unless: -> { layoutpage? || language_root? }
 
-    before_create -> { versions.build },
-      if: -> { versions.none? }
+    after_initialize :ensure_draft_version, if: :new_record?
 
     before_save :set_language_code,
       if: -> { language.present? }
@@ -179,7 +189,7 @@ module Alchemy
       end
 
       def searchable_alchemy_resource_attributes
-        %w[name urlname title]
+        %w[name urlname]
       end
 
       # @return the language root page for given language id.
@@ -213,8 +223,7 @@ module Alchemy
           .call(changed_attributes: {
             parent: new_parent,
             language: new_parent&.language,
-            name: new_name,
-            title: new_name
+            name: new_name
           })
         if source.children.any?
           source.copy_children_to(page)
@@ -402,6 +411,19 @@ module Alchemy
       PublishPageJob.perform_later(id, public_on: current_time)
     end
 
+    # Returns true if the draft version has changes not yet published.
+    #
+    # Compares the updated_at timestamp of the draft_version against the
+    # updated_at timestamp of the public_version. If there's no public_version,
+    # the page has never been published and always has unpublished changes.
+    #
+    # @return [Boolean]
+    def has_unpublished_changes?
+      return true unless public_version
+
+      draft_version.updated_at > public_version.updated_at
+    end
+
     # Sets the public_on date on the published version
     #
     # Builds a new version if none exists yet.
@@ -458,6 +480,54 @@ module Alchemy
       attribute_fixed?(:public_until) ? fixed_attributes[:public_until] : public_version&.public_until
     end
 
+    # Returns the title from the public version, falling back to draft version
+    #
+    # If it's a fixed attribute then the fixed value is returned instead
+    #
+    def title
+      return fixed_attributes[:title] if attribute_fixed?(:title)
+
+      public_version&.title || draft_version&.title
+    end
+
+    # Returns the meta_description from the public version, falling back to draft version
+    #
+    # If it's a fixed attribute then the fixed value is returned instead
+    #
+    def meta_description
+      return fixed_attributes[:meta_description] if attribute_fixed?(:meta_description)
+
+      public_version&.meta_description || draft_version&.meta_description
+    end
+
+    # Returns the meta_keywords from the public version, falling back to draft version
+    #
+    # If it's a fixed attribute then the fixed value is returned instead
+    #
+    def meta_keywords
+      return fixed_attributes[:meta_keywords] if attribute_fixed?(:meta_keywords)
+
+      public_version&.meta_keywords || draft_version&.meta_keywords
+    end
+
+    # @deprecated Use draft_version.title= instead
+    def title=(value)
+      draft_version&.title = value
+    end
+    deprecate "title=": :"page.draft_version.title=", deprecator: Alchemy::Deprecation
+
+    # @deprecated Use draft_version.meta_description= instead
+    def meta_description=(value)
+      draft_version&.meta_description = value
+    end
+    deprecate "meta_description=": :"page.draft_version.meta_description=", deprecator: Alchemy::Deprecation
+
+    # @deprecated Use draft_version.meta_keywords= instead
+    def meta_keywords=(value)
+      draft_version&.meta_keywords = value
+    end
+    deprecate "meta_keywords=": :"page.draft_version.meta_keywords=", deprecator: Alchemy::Deprecation
+
     # Returns the name of the creator of this page.
     #
     # If no creator could be found or associated user model
@@ -499,9 +569,18 @@ module Alchemy
 
     private
 
+    def ensure_draft_version
+      self.draft_version ||= versions.build
+    end
+
     def set_fixed_attributes
       fixed_attributes.all.each do |attribute, value|
-        send(:"#{attribute}=", value)
+        attribute_name = attribute.to_s
+        if PageVersion::METADATA_ATTRIBUTES.include?(attribute_name)
+          draft_version&.send(:"#{attribute}=", value)
+        else
+          send(:"#{attribute}=", value)
+        end
       end
     end
 

data/app/models/alchemy/page_definition.rb

@@ -4,7 +4,6 @@ module Alchemy
   class PageDefinition
     include ActiveModel::Model
     include ActiveModel::Attributes
-    include Alchemy::Hints
 
     extend ActiveModel::Translation
 
@@ -22,6 +21,10 @@ module Alchemy
     attribute :editable_by
     attribute :hint
 
+    # Needs to be down here in order to have the attribute reader
+    # available after the attribute is defined.
+    include Alchemy::Hints
+
     validates :name,
       presence: true,
       format: {

data/app/models/alchemy/page_version.rb

@@ -2,19 +2,29 @@
 
 module Alchemy
   class PageVersion < BaseRecord
+    include Alchemy::Publishable
+
+    # Metadata attributes that are versioned (moved from Page)
+    METADATA_ATTRIBUTES = %w[
+      title
+      meta_description
+      meta_keywords
+    ].freeze
+
     belongs_to :page, class_name: "Alchemy::Page", inverse_of: :versions, touch: true
 
     has_many :elements, -> { order(:position) },
       class_name: "Alchemy::Element",
       inverse_of: :page_version
 
-    scope :drafts, -> { where(public_on: nil).order(updated_at: :desc) }
-    scope :published, -> { where.not(public_on: nil).order(public_on: :desc) }
+    before_create :set_title_from_page
+
+    class << self
+      alias_method :drafts, :draft
+      deprecate drafts: :draft, deprecator: Alchemy::Deprecation
 
-    def self.public_on(time = Time.current)
-      where("#{table_name}.public_on <= :time AND " \
-            "(#{table_name}.public_until IS NULL " \
-            "OR #{table_name}.public_until >= :time)", time: time)
+      alias_method :public_on, :published
+      deprecate public_on: :published, deprecator: Alchemy::Deprecation
     end
 
     before_destroy :delete_elements
@@ -54,5 +64,11 @@ module Alchemy
     def delete_elements
       DeleteElements.new(elements).call
     end
+
+    def set_title_from_page
+      return if title.present?
+
+      self.title = page&.name
+    end
   end
 end

data/app/models/alchemy/picture.rb

@@ -28,7 +28,6 @@ module Alchemy
       large: "240x180"
     }.with_indifferent_access.freeze
 
-    include Alchemy::Logger
     include Alchemy::NameConversions
     include Alchemy::Taggable
     include Alchemy::TouchElements
@@ -63,6 +62,8 @@ module Alchemy
       @_preprocessor_class = klass
     end
 
+    before_create :set_name, if: :image_file_name
+
     include Alchemy.storage_adapter.picture_class_methods
 
     # We need to define this method here to have it available in the validations below.
@@ -76,7 +77,7 @@ module Alchemy
     validates_size_of :image_file, maximum: Alchemy.config.uploader.file_size_limit.megabytes
     validate :image_file_type_allowed, if: -> { image_file.present? }
 
-    stampable stamper_class_name: Alchemy.user_class_name
+    stampable stamper_class_name: Alchemy.config.user_class_name
 
     scope :named, ->(name) { where("#{table_name}.name LIKE ?", "%#{name}%") }
     scope :recent, -> { where("#{table_name}.created_at > ?", Time.current - 24.hours).order(:created_at) }
@@ -148,7 +149,7 @@ module Alchemy
 
       self.class.url_class.new(self).call(options)
     rescue Alchemy.storage_adapter.rescuable_errors => e
-      log_warning(e.message)
+      Logger.warn(e.message)
       nil
     end
 
@@ -196,14 +197,6 @@ module Alchemy
       end
     end
 
-    # Returns a humanized, readable name from image filename.
-    #
-    def humanized_name
-      return "" if image_file_name.blank?
-
-      convert_to_humanized_name(image_file_name, image_file_extension)
-    end
-
     # Returns the format the image should be rendered with
     #
     # Only returns a format differing from original if an +image_output_format+
@@ -288,6 +281,12 @@ module Alchemy
 
     private
 
+    # Returns a humanized, readable name from image filename.
+    #
+    def set_name
+      self.name ||= Alchemy.storage_adapter.image_file_basename(self).humanize
+    end
+
     def image_file_type_allowed
       unless image_file_extension&.in?(self.class.allowed_filetypes)
         errors.add(:image_file, Alchemy.t("not a valid image"))

data/app/models/alchemy/picture_variant.rb

@@ -10,8 +10,6 @@ module Alchemy
   class PictureVariant
     extend Forwardable
 
-    include Alchemy::Logger
-
     ANIMATED_IMAGE_FORMATS = %w[gif webp]
     TRANSPARENT_IMAGE_FORMATS = %w[gif webp png]
     ENCODABLE_IMAGE_FORMATS = %w[jpg jpeg webp]
@@ -57,7 +55,7 @@ module Alchemy
       image = processed_image(image, @options)
       encoded_image(image, @options)
     rescue MissingImageFileError, WrongImageFormatError => e
-      log_warning(e.message)
+      Logger.warn(e.message)
       nil
     end
 

data/app/models/alchemy/resource.rb

@@ -221,7 +221,7 @@ module Alchemy
         attributes.select { |a| searchable_attribute?(a) }
           .concat(searchable_relation_attributes(attributes))
           .collect { |h| h[:name] }
-      end
+      end.sort
     end
 
     # Search field input name

data/app/models/alchemy/storage_adapter/active_storage.rb

@@ -4,8 +4,6 @@ module Alchemy
       module PictureClassMethods
         def self.included(base)
           base.has_one_attached :image_file do |attachable|
-            # Only works in Rails 7.1+
-            # https://github.com/rails/rails/pull/47473
             Alchemy.storage_adapter.preprocessor_class.new(attachable).call
             Alchemy.storage_adapter.preprocessor_class.generate_thumbs!(attachable)
           end
@@ -98,6 +96,13 @@ module Alchemy
         Attachment.with_attached_file.joins(:file_blob).where.not(active_storage_blobs: {content_type: file_type})
       end
 
+      # @param [Alchemy::Attachment]
+      # @return [String]
+      def file_basename(attachment)
+        filename = attachment.file&.filename.to_s
+        File.basename(filename, File.extname(filename))
+      end
+
       # @param [Alchemy::Attachment]
       # @return [String]
       def file_name(attachment)
@@ -128,6 +133,13 @@ module Alchemy
         picture.image_file&.variable?
       end
 
+      # @param [Alchemy::Picture]
+      # @return [String]
+      def image_file_basename(picture)
+        filename = picture.image_file&.filename.to_s
+        File.basename(filename, File.extname(filename))
+      end
+
       # @param [Alchemy::Picture]
       # @return [String]
       def image_file_name(picture)

data/app/models/alchemy/storage_adapter/dragonfly.rb

@@ -127,6 +127,12 @@ module Alchemy
         attachment.read_attribute(:file_name)
       end
 
+      # @param [Alchemy::Attachment]
+      # @return [String]
+      def file_basename(attachment)
+        attachment.file&.basename&.to_s
+      end
+
       # @param [Alchemy::Attachment]
       # @return [Integer]
       def file_size(attachment)
@@ -152,6 +158,12 @@ module Alchemy
         image_file_extension(picture).in?(CONVERTIBLE_FILE_FORMATS)
       end
 
+      # @param [Alchemy::Picture]
+      # @return [String]
+      def image_file_basename(picture)
+        picture.image_file&.basename&.to_s
+      end
+
       # @param [Alchemy::Picture]
       # @return [String]
       def image_file_name(picture)

data/app/models/alchemy/storage_adapter.rb

@@ -9,12 +9,14 @@ module Alchemy
       :by_file_format_scope,
       :by_file_type_scope,
       :not_file_type_scope,
+      :file_basename,
       :file_extension,
       :file_formats,
       :file_mime_type,
       :file_name,
       :file_size,
       :has_convertible_format?,
+      :image_file_basename,
       :image_file_extension,
       :image_file_format,
       :image_file_height,

data/app/models/concerns/alchemy/picture_thumbnails.rb

@@ -66,20 +66,20 @@ module Alchemy
     # image displayed in the frontend.
     #
     # @return [String]
-    def thumbnail_url
+    def thumbnail_url(size: "160x120")
       return if picture.nil?
 
-      picture.url(thumbnail_url_options) || "alchemy/missing-image.svg"
+      picture.url(thumbnail_url_options(size: size)) || "alchemy/missing-image.svg"
     end
 
     # Thumbnail rendering options
     #
     # @return [HashWithIndifferentAccess]
-    def thumbnail_url_options
+    def thumbnail_url_options(size: "160x120")
       crop = !!settings[:crop]
 
       {
-        size: "160x120",
+        size: size,
         crop: crop,
         crop_from: crop && crop_from.presence || default_crop_from&.join("x"),
         crop_size: crop && crop_size.presence || default_crop_size&.join("x"),

data/app/models/concerns/alchemy/publishable.rb

@@ -0,0 +1,54 @@
+module Alchemy
+  module Publishable
+    extend ActiveSupport::Concern
+
+    included do
+      scope :draft, -> { where(public_on: nil) }
+      scope :scheduled, -> { where.not(public_on: nil) }
+
+      scope :published, ->(at: Time.current) {
+        scheduled
+          .where("#{table_name}.public_on <= :at", at:)
+          .where(public_until: nil).or(
+            where("#{table_name}.public_until > :at", at:)
+          )
+      }
+    end
+
+    # Determines if this record is public
+    #
+    # Takes the two timestamps +public_on+ and +public_until+
+    # and returns true if the time given (+Time.current+ per default)
+    # is in this timespan.
+    #
+    # @param time [DateTime] (Time.current)
+    # @returns Boolean
+    def public?(time = Time.current)
+      already_public_for?(time) && still_public_for?(time)
+    end
+    alias_method :public, :public?
+
+    # Determines if this record is publishable
+    #
+    # A record is publishable if a +public_on+ timestamp is set and not expired yet.
+    #
+    # @returns Boolean
+    def publishable?
+      !public_on.nil? && still_public_for?
+    end
+
+    # Determines if this record is already public for given time
+    # @param time [DateTime] (Time.current)
+    # @returns Boolean
+    def already_public_for?(time = Time.current)
+      !public_on.nil? && public_on <= time
+    end
+
+    # Determines if this record is still public for given time
+    # @param time [DateTime] (Time.current)
+    # @returns Boolean
+    def still_public_for?(time = Time.current)
+      public_until.nil? || public_until >= time
+    end
+  end
+end

data/app/serializers/alchemy/page_tree_serializer.rb

@@ -7,43 +7,23 @@ module Alchemy
     end
 
     def pages
-      tree = []
-      path = [{id: object.parent_id, children: tree}]
-      page_list = object.self_and_descendants.includes(:public_version, {language: :site})
       base_level = object.level - 1
-      # Load folded pages in advance
-      folded_user_pages = FoldedPage.folded_for_user(opts[:user]).pluck(:page_id)
-      folded_depth = Float::INFINITY
-
-      page_list.each_with_index do |page, i|
-        has_children = page_list[i + 1] && page_list[i + 1].parent_id == page.id
-        folded = has_children && folded_user_pages.include?(page.id)
+      build_pages_tree([object], base_level)
+    end
 
-        if page.depth > folded_depth
-          next
-        else
-          folded_depth = Float::INFINITY
-        end
+    private
 
-        # If this page is folded, skip all pages that are on a higher level (further down the tree).
-        if folded && !opts[:full]
-          folded_depth = page.depth
-        end
+    def build_pages_tree(pages, level)
+      pages.map do |page|
+        # Use association target directly to avoid triggering queries
+        children = page.association(:children).loaded? ? page.association(:children).target : []
+        has_children = children.any?
+        folded = !has_children && !page.leaf?
 
-        if page.parent_id != path.last[:id]
-          if path.map { |o| o[:id] }.include?(page.parent_id) # Lower level
-            path.pop while path.last[:id] != page.parent_id
-          else # One level up
-            path << path.last[:children].last
-          end
+        page_hash(page, level, folded).tap do |hash|
+          hash[:children] = build_pages_tree(children, level + 1)
         end
-
-        level = path.count + base_level
-
-        path.last[:children] << page_hash(page, level, folded)
       end
-
-      tree
     end
 
     protected

data/app/services/alchemy/copy_page.rb

@@ -28,8 +28,14 @@ module Alchemy
       depth
       urlname
       cached_tag_list
+      title
+      meta_description
+      meta_keywords
     ]
 
+    # Metadata to copy via nested attributes (title is derived from page.name)
+    METADATA_ATTRIBUTES_TO_COPY = (Alchemy::PageVersion::METADATA_ATTRIBUTES - %w[title]).freeze
+
     attr_reader :page
 
     # @param page [Alchemy::Page]
@@ -70,6 +76,7 @@ module Alchemy
         .merge(DEFAULT_ATTRIBUTES_FOR_COPY)
         .merge(differences)
       desired_attributes["name"] = best_name_for_copy(source_attributes, desired_attributes)
+      desired_attributes["draft_version_attributes"] = draft_version_attributes_for_copy
       desired_attributes.except(*SKIPPED_ATTRIBUTES_ON_COPY)
     end
 
@@ -94,5 +101,15 @@ module Alchemy
         desired_name
       end
     end
+
+    # Builds nested attributes for draft_version metadata (except title).
+    # Title is handled by PageVersion#set_title_from_page callback based on page.name.
+    def draft_version_attributes_for_copy
+      return {} unless page.draft_version
+
+      METADATA_ATTRIBUTES_TO_COPY.each_with_object({}) do |attr, hash|
+        hash[attr] = page.draft_version.send(attr)
+      end
+    end
   end
 end

data/app/services/alchemy/duplicate_element.rb

@@ -36,7 +36,7 @@ module Alchemy
       new_element.save!
 
       nested_elements = repository.children_of(source_element)
-      nested_elements = nested_elements.visible if publishable_only
+      nested_elements = nested_elements.publishable if publishable_only
       Element.acts_as_list_no_update do
         nested_elements.each.with_index(1) do |nested_element, position|
           self.class.new(nested_element, repository: repository, publishable_only: publishable_only).call(