alchemy_cms 5.1.4 → 6.0.0.b1

data/app/models/alchemy/ingredients/text.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    # A simple line of text
+    #
+    # Optionally it can have a link
+    #
+    class Text < Alchemy::Ingredient
+      store_accessor :data,
+        :link,
+        :link_target,
+        :link_title,
+        :link_class_name
+    end
+  end
+end

data/app/models/alchemy/ingredients/video.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    # A video attachment
+    #
+    class Video < Alchemy::Ingredient
+      store_accessor :data,
+        :allow_fullscreen,
+        :autoplay,
+        :controls,
+        :height,
+        :loop,
+        :muted,
+        :preload,
+        :width
+
+      related_object_alias :attachment, class_name: "Alchemy::Attachment"
+
+      delegate :name, to: :attachment, allow_nil: true
+
+      # The first 30 characters of the attachments name
+      #
+      # Used by the Element#preview_text method.
+      #
+      # @param [Integer] max_length (30)
+      #
+      def preview_text(max_length = 30)
+        name.to_s[0..max_length - 1]
+      end
+    end
+  end
+end

data/app/models/alchemy/language.rb

@@ -54,9 +54,6 @@ module Alchemy
     after_update :set_pages_language,
       if: :should_set_pages_language?
 
-    after_update :unpublish_pages,
-      if: :should_unpublish_pages?
-
     before_destroy if: -> { pages.any? } do
       errors.add(:pages, :still_present)
       throw(:abort)
@@ -170,13 +167,5 @@ module Alchemy
     def set_pages_language
       pages.update_all language_code: code
     end
-
-    def should_unpublish_pages?
-      saved_changes[:public] == [true, false]
-    end
-
-    def unpublish_pages
-      pages.update_all(public_on: nil, public_until: nil)
-    end
   end
 end

data/app/models/alchemy/page.rb

@@ -35,6 +35,12 @@
 #  locked_at        :datetime
 #
 
+require_dependency "alchemy/page/fixed_attributes"
+require_dependency "alchemy/page/page_scopes"
+require_dependency "alchemy/page/page_natures"
+require_dependency "alchemy/page/page_naming"
+require_dependency "alchemy/page/page_elements"
+
 module Alchemy
   class Page < BaseRecord
     include Alchemy::Hints
@@ -109,6 +115,9 @@ module Alchemy
     has_many :folded_pages
     has_many :legacy_urls, class_name: "Alchemy::LegacyPageUrl"
     has_many :nodes, class_name: "Alchemy::Node", inverse_of: :page
+    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"
 
     before_validation :set_language,
       if: -> { language.nil? }
@@ -117,6 +126,9 @@ 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? }
+
     before_save :set_language_code,
       if: -> { language.present? }
 
@@ -126,9 +138,6 @@ module Alchemy
     before_save :inherit_restricted_status,
       if: -> { parent && parent.restricted? }
 
-    before_save :set_published_at,
-      if: -> { public_on.present? && published_at.nil? }
-
     before_save :set_fixed_attributes,
       if: -> { fixed_attributes.any? }
 
@@ -138,14 +147,22 @@ module Alchemy
     after_update -> { nodes.update_all(updated_at: Time.current) }
 
     # Concerns
-    include Alchemy::Page::PageScopes
-    include Alchemy::Page::PageNatures
-    include Alchemy::Page::PageNaming
-    include Alchemy::Page::PageElements
+    include PageScopes
+    include PageNatures
+    include PageNaming
+    include PageElements
 
     # site_name accessor
     delegate :name, to: :site, prefix: true, allow_nil: true
 
+    # Old public_on and public_until attributes for historical reasons
+    #
+    # These attributes now exist on the page versions
+    #
+    attr_readonly :legacy_public_on, :legacy_public_until
+    deprecate :legacy_public_on, deprecator: Alchemy::Deprecation
+    deprecate :legacy_public_until, deprecator: Alchemy::Deprecation
+
     # Class methods
     #
     class << self
@@ -207,11 +224,13 @@ module Alchemy
       # @return [Alchemy::Page]
       #
       def copy(source, differences = {})
-        page = Alchemy::Page.new(attributes_from_source_for_copy(source, differences))
-        page.tag_list = source.tag_list
-        if page.save!
-          copy_elements(source, page)
-          page
+        transaction do
+          page = Alchemy::Page.new(attributes_from_source_for_copy(source, differences))
+          page.tag_list = source.tag_list
+          if page.save!
+            copy_elements(source, page)
+            page
+          end
         end
       end
 
@@ -291,7 +310,9 @@ module Alchemy
     # Instance methods
     #
 
-    # Returns elements from page.
+    # Returns elements from pages public version.
+    #
+    # You can pass another page_version to load elements from in the options.
     #
     # @option options [Array<String>|String] :only
     #   Returns only elements with given names
@@ -310,11 +331,14 @@ module Alchemy
     # @option options [Class] :finder (Alchemy::ElementsFinder)
     #   A class that will return elements from page.
     #   Use this for your custom element loading logic.
+    # @option options [Alchemy::PageVersion] :page_version
+    #   A page version to load elements from.
+    #   Uses the pages public_version by default.
     #
     # @return [ActiveRecord::Relation]
     def find_elements(options = {})
       finder = options[:finder] || Alchemy::ElementsFinder.new(options)
-      finder.elements(page: self)
+      finder.elements(page_version: options[:page_version] || public_version)
     end
 
     # = The url_path for this page
@@ -423,22 +447,36 @@ module Alchemy
       end
     end
 
-    # Publishes the page.
+    # Creates a public version of the page.
     #
-    # Sets +public_on+ and the +published_at+ value to current time
-    # and resets +public_until+ to nil
+    # Sets the +published_at+ value to current time
     #
     # The +published_at+ attribute is used as +cache_key+.
     #
-    def publish!
-      current_time = Time.current
-      update_columns(
-        published_at: current_time,
-        public_on: already_public_for?(current_time) ? public_on : current_time,
-        public_until: still_public_for?(current_time) ? public_until : nil,
-      )
+    def publish!(current_time = Time.current)
+      update(published_at: current_time)
+      PublishPageJob.perform_later(self, public_on: current_time)
     end
 
+    # Sets the public_on date on the published version
+    #
+    # Builds a new version if none exists yet.
+    # Destroys public version if empty time is set
+    #
+    def public_on=(time)
+      if public_version && time.blank?
+        public_version.destroy!
+        # Need to reset the public version on the instance so we do not need to reload
+        self.public_version = nil
+      elsif public_version
+        public_version.public_on = time
+      elsif time.present?
+        versions.build(public_on: time)
+      end
+    end
+
+    delegate :public_until=, to: :public_version, allow_nil: true
+
     # Updates an Alchemy::Page based on a new ordering to be applied to it
     #
     # Note: Page's urls should not be updated (and a legacy URL created) if nesting is OFF
@@ -460,7 +498,7 @@ module Alchemy
 
     # Holds an instance of +FixedAttributes+
     def fixed_attributes
-      @_fixed_attributes ||= Alchemy::Page::FixedAttributes.new(self)
+      @_fixed_attributes ||= FixedAttributes.new(self)
     end
 
     # True if given attribute name is defined as fixed
@@ -479,12 +517,12 @@ module Alchemy
       (editor_roles & user.alchemy_roles).any?
     end
 
-    # Returns the value of +public_on+ attribute
+    # Returns the value of +public_on+ attribute from public version
     #
     # If it's a fixed attribute then the fixed value is returned instead
     #
     def public_on
-      attribute_fixed?(:public_on) ? fixed_attributes[:public_on] : self[:public_on]
+      attribute_fixed?(:public_on) ? fixed_attributes[:public_on] : public_version&.public_on
     end
 
     # Returns the value of +public_until+ attribute
@@ -492,7 +530,7 @@ module Alchemy
     # If it's a fixed attribute then the fixed value is returned instead
     #
     def public_until
-      attribute_fixed?(:public_until) ? fixed_attributes[:public_until] : self[:public_until]
+      attribute_fixed?(:public_until) ? fixed_attributes[:public_until] : public_version&.public_until
     end
 
     # Returns the name of the creator of this page.
@@ -556,9 +594,5 @@ module Alchemy
     def create_legacy_url
       legacy_urls.find_or_create_by(urlname: urlname_before_last_save)
     end
-
-    def set_published_at
-      self.published_at = Time.current
-    end
   end
 end

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

@@ -1,66 +1,68 @@
 # frozen_string_literal: true
 
 module Alchemy
-  # = Fixed page attributes
-  #
-  # Fixed page attributes are not allowed to be changed by the user.
-  #
-  # Define fixed page attributes on the page layout definition of a page.
-  #
-  # == Example
-  #
-  #     # page_layout.yml
-  #     - name: Index
-  #       unique: true
-  #       fixed_attributes:
-  #         - public_on: nil
-  #         - public_until: nil
-  #
-  class Page::FixedAttributes
-    attr_reader :page
-
-    def initialize(page)
-      @page = page
-    end
-
-    # All fixed attributes defined on page
+  class Page < BaseRecord
+    # = Fixed page attributes
     #
-    # Aliased as +#all+
+    # Fixed page attributes are not allowed to be changed by the user.
     #
-    # @return Hash
+    # Define fixed page attributes on the page layout definition of a page.
     #
-    def attributes
-      @_attributes ||= page.definition.fetch("fixed_attributes", {}).symbolize_keys
-    end
-    alias_method :all, :attributes
-
-    # True if fixed attributes are defined on page
-    #
-    # Aliased as +#present?+
+    # == Example
     #
-    # @return Boolean
+    #     # page_layout.yml
+    #     - name: Index
+    #       unique: true
+    #       fixed_attributes:
+    #         - public_on: nil
+    #         - public_until: nil
     #
-    def any?
-      attributes.present?
-    end
-    alias_method :present?, :any?
+    class FixedAttributes
+      attr_reader :page
 
-    # True if given attribute name is defined on page
-    #
-    # @return Boolean
-    #
-    def fixed?(name)
-      return false if name.nil?
+      def initialize(page)
+        @page = page
+      end
 
-      attributes.key?(name.to_sym)
-    end
+      # All fixed attributes defined on page
+      #
+      # Aliased as +#all+
+      #
+      # @return Hash
+      #
+      def attributes
+        @_attributes ||= page.definition.fetch("fixed_attributes", {}).symbolize_keys
+      end
+      alias_method :all, :attributes
 
-    # Returns the attribute by key
-    #
-    def [](name)
-      return nil if name.nil?
+      # True if fixed attributes are defined on page
+      #
+      # Aliased as +#present?+
+      #
+      # @return Boolean
+      #
+      def any?
+        attributes.present?
+      end
+      alias_method :present?, :any?
+
+      # True if given attribute name is defined on page
+      #
+      # @return Boolean
+      #
+      def fixed?(name)
+        return false if name.nil?
+
+        attributes.key?(name.to_sym)
+      end
+
+      # Returns the attribute by key
+      #
+      def [](name)
+        return nil if name.nil?
 
-      attributes[name.to_sym]
+        attributes[name.to_sym]
+      end
     end
   end
 end

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

@@ -1,230 +1,218 @@
 # frozen_string_literal: true
 
 module Alchemy
-  module Page::PageElements
-    extend ActiveSupport::Concern
-
-    included do
-      attr_accessor :autogenerate_elements
-
-      has_many :all_elements,
-        -> { order(:position) },
-        class_name: "Alchemy::Element",
-        inverse_of: :page
-      has_many :elements,
-        -> { order(:position).not_nested.unfixed.available },
-        class_name: "Alchemy::Element",
-        inverse_of: :page
-      has_many :trashed_elements,
-        -> { Element.trashed.order(:position) },
-        class_name: "Alchemy::Element",
-        inverse_of: :page
-      has_many :fixed_elements,
-        -> { order(:position).fixed.available },
-        class_name: "Alchemy::Element",
-        inverse_of: :page
-      has_many :dependent_destroyable_elements,
-        -> { not_nested },
-        class_name: "Alchemy::Element",
-        dependent: :destroy
-      has_many :contents, through: :elements
-      has_and_belongs_to_many :to_be_swept_elements, -> { distinct },
-        class_name: "Alchemy::Element",
-        join_table: ElementToPage.table_name
-
-      after_create :generate_elements,
-        unless: -> { autogenerate_elements == false }
-
-      after_update :trash_not_allowed_elements!,
-        if: :saved_change_to_page_layout?
-
-      after_update :generate_elements,
-        if: :saved_change_to_page_layout?
-    end
-
-    module ClassMethods
-      # Copy page elements
-      #
-      # @param source [Alchemy::Page]
-      # @param target [Alchemy::Page]
-      # @return [Array]
-      #
-      def copy_elements(source, target)
-        source_elements = source.all_elements.not_nested.not_trashed
-        source_elements.order(:position).map do |source_element|
-          Element.copy(source_element, {
-            page_id: target.id,
-          }).tap(&:move_to_bottom)
+  class Page < BaseRecord
+    module PageElements
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :autogenerate_elements
+
+        with_options(
+          class_name: "Alchemy::Element",
+          through: :public_version,
+          inverse_of: :page,
+          source: :elements,
+        ) do
+          has_many :all_elements
+          has_many :elements, -> { not_nested.unfixed.available }
+          has_many :fixed_elements, -> { fixed.available }
         end
+
+        has_many :contents, through: :elements
+        has_and_belongs_to_many :to_be_swept_elements, -> { distinct },
+          class_name: "Alchemy::Element",
+          join_table: ElementToPage.table_name
+
+        after_create :generate_elements,
+          unless: -> { autogenerate_elements == false }
       end
-    end
 
-    # All available element definitions that can actually be placed on current page.
-    #
-    # It extracts all definitions that are unique or limited and already on page.
-    #
-    # == Example of unique element:
-    #
-    #   - name: headline
-    #     unique: true
-    #     contents:
-    #     - name: headline
-    #       type: EssenceText
-    #
-    # == Example of limited element:
-    #
-    #   - name: article
-    #     amount: 2
-    #     contents:
-    #     - name: text
-    #       type: EssenceRichtext
-    #
-    def available_element_definitions(only_element_named = nil)
-      @_element_definitions ||= if only_element_named
-          definition = Element.definition_by_name(only_element_named)
-          element_definitions_by_name(definition["nestable_elements"])
-        else
-          element_definitions
+      module ClassMethods
+        # Copy page elements
+        #
+        # @param source [Alchemy::Page]
+        # @param target [Alchemy::Page]
+        # @return [Array]
+        #
+        def copy_elements(source, target)
+          repository = source.draft_version.element_repository
+          transaction do
+            Element.acts_as_list_no_update do
+              repository.not_nested.each.with_index(1) do |element, position|
+                Alchemy::DuplicateElement.new(element, repository: repository).call(
+                  page_version_id: target.draft_version.id,
+                  position: position,
+                )
+              end
+            end
+          end
         end
+      end
 
-      return [] if @_element_definitions.blank?
+      # All available element definitions that can actually be placed on current page.
+      #
+      # It extracts all definitions that are unique or limited and already on page.
+      #
+      # == Example of unique element:
+      #
+      #   - name: headline
+      #     unique: true
+      #     contents:
+      #     - name: headline
+      #       type: EssenceText
+      #
+      # == Example of limited element:
+      #
+      #   - name: article
+      #     amount: 2
+      #     contents:
+      #     - name: text
+      #       type: EssenceRichtext
+      #
+      def available_element_definitions(only_element_named = nil)
+        @_element_definitions ||= if only_element_named
+            definition = Element.definition_by_name(only_element_named)
+            element_definitions_by_name(definition["nestable_elements"])
+          else
+            element_definitions
+          end
 
-      existing_elements = all_elements.not_nested.not_trashed
-      @_existing_element_names = existing_elements.pluck(:name)
-      delete_unique_element_definitions!
-      delete_outnumbered_element_definitions!
+        return [] if @_element_definitions.blank?
 
-      @_element_definitions
-    end
+        existing_elements = draft_version.elements.not_nested
+        @_existing_element_names = existing_elements.pluck(:name)
+        delete_unique_element_definitions!
+        delete_outnumbered_element_definitions!
 
-    # 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"] }
-    end
+        @_element_definitions
+      end
 
-    # Available element definitions excluding nested unique elements.
-    #
-    def available_elements_within_current_scope(parent)
-      @_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"]
-          end
-        else
-          available_element_definitions
-        end
-    end
+      # 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"] }
+      end
 
-    # All element definitions defined for page's page layout
-    #
-    # Warning: Since elements can be unique or limited in number,
-    # it is more safe to ask for +available_element_definitions+
-    #
-    def element_definitions
-      @_element_definitions ||= element_definitions_by_name(element_definition_names)
-    end
+      # Available element definitions excluding nested unique elements.
+      #
+      def available_elements_within_current_scope(parent)
+        @_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"]
+            end
+          else
+            available_element_definitions
+          end
+      end
 
-    # All element definitions defined for page's page layout including nestable element definitions
-    #
-    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"])
+      # All element definitions defined for page's page layout
+      #
+      # Warning: Since elements can be unique or limited in number,
+      # it is more safe to ask for +available_element_definitions+
+      #
+      def element_definitions
+        @_element_definitions ||= element_definitions_by_name(element_definition_names)
       end
-      definitions.uniq { |d| d["name"] }
-    end
 
-    # All names of elements that are defined in the page definition.
-    #
-    # Assign elements to a page in +config/alchemy/page_layouts.yml+.
-    #
-    # == Example of page_layouts.yml:
-    #
-    #   - name: contact
-    #     elements: [headline, contactform]
-    #
-    def element_definition_names
-      definition["elements"] || []
-    end
+      # All element definitions defined for page's page layout including nestable element definitions
+      #
+      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"] }
+      end
 
-    # Element definitions with given name(s)
-    #
-    # @param [Array || String]
-    #   one or many Alchemy::Element names. Pass +'all'+ to get all Element definitions
-    # @return [Array]
-    #   An Array of element definitions
-    #
-    def element_definitions_by_name(names)
-      return [] if names.blank?
-
-      if names.to_s == "all"
-        Element.definitions
-      else
-        Element.definitions.select { |e| names.include? e["name"] }
+      # All names of elements that are defined in the page definition.
+      #
+      # Assign elements to a page in +config/alchemy/page_layouts.yml+.
+      #
+      # == Example of page_layouts.yml:
+      #
+      #   - name: contact
+      #     elements: [headline, contactform]
+      #
+      def element_definition_names
+        definition["elements"] || []
       end
-    end
 
-    # Returns all elements that should be feeded via rss.
-    #
-    # Define feedable elements in your +page_layouts.yml+:
-    #
-    #   - name: news
-    #     feed: true
-    #     feed_elements: [element_name, element_2_name]
-    #
-    def feed_elements
-      elements.named(definition["feed_elements"])
-    end
+      # Element definitions with given name(s)
+      #
+      # @param [Array || String]
+      #   one or many Alchemy::Element names. Pass +'all'+ to get all Element definitions
+      # @return [Array]
+      #   An Array of element definitions
+      #
+      def element_definitions_by_name(names)
+        return [] if names.blank?
 
-    # Returns an array of all EssenceRichtext contents ids from not folded elements
-    #
-    def richtext_contents_ids
-      Alchemy::Content.joins(:element)
-        .where(Element.table_name => { page_id: id, folded: false })
-        .select(&:has_tinymce?)
-        .collect(&:id)
-    end
+        if names.to_s == "all"
+          Element.definitions
+        else
+          Element.definitions.select { |e| names.include? e["name"] }
+        end
+      end
 
-    private
+      # Returns all elements that should be feeded via rss.
+      #
+      # Define feedable elements in your +page_layouts.yml+:
+      #
+      #   - name: news
+      #     feed: true
+      #     feed_elements: [element_name, element_2_name]
+      #
+      def feed_elements
+        elements.named(definition["feed_elements"])
+      end
 
-    # Looks in the page_layout descripion, if there are elements to autogenerate.
-    #
-    # And if so, it generates them.
-    #
-    def generate_elements
-      existing_elements = all_elements.not_nested.not_trashed
-      existing_element_names = existing_elements.pluck(:name).uniq
-      definition.fetch("autogenerate", []).each do |element_name|
-        next if existing_element_names.include?(element_name)
+      # Returns an array of all EssenceRichtext contents ids from not folded elements
+      #
+      def richtext_contents_ids
+        Alchemy::Content.joins(:element)
+          .where(Element.table_name => { page_version_id: draft_version.id, folded: false })
+          .select(&:has_tinymce?)
+          .collect(&:id)
+      end
 
-        Element.create(page: self, name: element_name)
+      # Returns an array of all Richtext ingredients ids from not folded elements
+      #
+      def richtext_ingredients_ids
+        Alchemy::Ingredient.richtexts.joins(:element)
+          .where(Element.table_name => { page_version_id: draft_version.id, folded: false })
+          .select(&:has_tinymce?)
+          .collect(&:id)
       end
-    end
 
-    # Trashes all elements that are not allowed for this page_layout.
-    def trash_not_allowed_elements!
-      not_allowed_elements = elements.where([
-        "#{Element.table_name}.name NOT IN (?)",
-        element_definition_names,
-      ])
-      not_allowed_elements.to_a.map(&:trash!)
-    end
+      private
 
-    # Deletes unique and already present definitions from @_element_definitions.
-    #
-    def delete_unique_element_definitions!
-      @_element_definitions.delete_if do |element|
-        element["unique"] && @_existing_element_names.include?(element["name"])
+      # Looks in the page_layout descripion, if there are elements to autogenerate.
+      #
+      # And if so, it generates them.
+      #
+      def generate_elements
+        definition.fetch("autogenerate", []).each do |element_name|
+          Element.create(page: self, page_version: draft_version, name: element_name)
+        end
+      end
+
+      # Deletes unique and already present definitions from @_element_definitions.
+      #
+      def delete_unique_element_definitions!
+        @_element_definitions.delete_if do |element|
+          element["unique"] && @_existing_element_names.include?(element["name"])
+        end
       end
-    end
 
-    # Deletes limited and outnumbered definitions from @_element_definitions.
-    #
-    def delete_outnumbered_element_definitions!
-      @_element_definitions.delete_if do |element|
-        outnumbered = @_existing_element_names.select { |name| name == element["name"] }
-        element["amount"] && outnumbered.count >= element["amount"].to_i
+      # Deletes limited and outnumbered definitions from @_element_definitions.
+      #
+      def delete_outnumbered_element_definitions!
+        @_element_definitions.delete_if do |element|
+          outnumbered = @_existing_element_names.select { |name| name == element["name"] }
+          element["amount"] && outnumbered.count >= element["amount"].to_i
+        end
       end
     end
   end