alchemy_cms 5.2.4 → 6.0.0.b1

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

@@ -1,237 +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(if: :saved_change_to_page_layout?) do
-        Alchemy::Deprecation.warn(
-          "Autogenerating elements on page_layout change is deprecated and will be removed from Alchemy 6.0"
-        )
-        generate_elements
-      end
-    end
+  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
 
-    module ClassMethods
-      deprecate :trashed_elements, deprecator: Alchemy::Deprecation
+        has_many :contents, through: :elements
+        has_and_belongs_to_many :to_be_swept_elements, -> { distinct },
+          class_name: "Alchemy::Element",
+          join_table: ElementToPage.table_name
 
-      # 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)
-        end
+        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
-    deprecate :trash_not_allowed_elements!, deprecator: Alchemy::Deprecation
+      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

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

@@ -1,85 +1,87 @@
 # frozen_string_literal: true
 
 module Alchemy
-  module Page::PageNaming
-    extend ActiveSupport::Concern
-    include NameConversions
-    RESERVED_URLNAMES = %w(admin messages new)
+  class Page < BaseRecord
+    module PageNaming
+      extend ActiveSupport::Concern
+      include NameConversions
+      RESERVED_URLNAMES = %w(admin messages new)
 
-    included do
-      before_validation :set_urlname,
-        if: :renamed?,
-        unless: -> { name.blank? }
+      included do
+        before_validation :set_urlname,
+          if: :renamed?,
+          unless: -> { name.blank? }
 
-      validates :name,
-        presence: true
-      validates :urlname,
-        uniqueness: { scope: [:language_id, :layoutpage], if: -> { urlname.present? } },
-        exclusion: { in: RESERVED_URLNAMES },
-        length: { minimum: 3, if: -> { urlname.present? } }
+        validates :name,
+          presence: true
+        validates :urlname,
+          uniqueness: { scope: [:language_id, :layoutpage], if: -> { urlname.present? } },
+          exclusion: { in: RESERVED_URLNAMES },
+          length: { minimum: 3, if: -> { urlname.present? } }
 
-      before_save :set_title,
-        if: -> { title.blank? }
+        before_save :set_title,
+          if: -> { title.blank? }
 
-      after_update :update_descendants_urlnames,
-        if: :saved_change_to_urlname?
+        after_update :update_descendants_urlnames,
+          if: :saved_change_to_urlname?
 
-      after_move :update_urlname!
-    end
+        after_move :update_urlname!
+      end
 
-    # Returns true if name or urlname has changed.
-    def renamed?
-      name_changed? || urlname_changed?
-    end
+      # Returns true if name or urlname has changed.
+      def renamed?
+        name_changed? || urlname_changed?
+      end
 
-    # Makes a slug of all ancestors urlnames including mine and delimit them be slash.
-    # So the whole path is stored as urlname in the database.
-    def update_urlname!
-      new_urlname = nested_url_name
-      if urlname != new_urlname
-        legacy_urls.create(urlname: urlname)
-        update_column(:urlname, new_urlname)
+      # Makes a slug of all ancestors urlnames including mine and delimit them be slash.
+      # So the whole path is stored as urlname in the database.
+      def update_urlname!
+        new_urlname = nested_url_name
+        if urlname != new_urlname
+          legacy_urls.create(urlname: urlname)
+          update_column(:urlname, new_urlname)
+        end
       end
-    end
 
-    # Returns always the last part of a urlname path
-    def slug
-      urlname.to_s.split("/").last
-    end
+      # Returns always the last part of a urlname path
+      def slug
+        urlname.to_s.split("/").last
+      end
 
-    private
+      private
 
-    def update_descendants_urlnames
-      reload
-      descendants.each(&:update_urlname!)
-    end
+      def update_descendants_urlnames
+        reload
+        descendants.each(&:update_urlname!)
+      end
 
-    # Sets the urlname to a url friendly slug.
-    # Either from name, or if present, from urlname.
-    # The urlname contains the whole path including parent urlnames.
-    def set_urlname
-      self[:urlname] = nested_url_name
-    end
+      # Sets the urlname to a url friendly slug.
+      # Either from name, or if present, from urlname.
+      # The urlname contains the whole path including parent urlnames.
+      def set_urlname
+        self[:urlname] = nested_url_name
+      end
 
-    def set_title
-      self[:title] = name
-    end
+      def set_title
+        self[:title] = name
+      end
 
-    # Converts the given name into an url friendly string.
-    #
-    # 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
+      # Converts the given name into an url friendly string.
+      #
+      # 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
-      if parent&.language_root?
-        converted_url_name
-      else
-        [parent&.urlname, converted_url_name].compact.join("/")
+      def nested_url_name
+        if parent&.language_root?
+          converted_url_name
+        else
+          [parent&.urlname, converted_url_name].compact.join("/")
+        end
       end
     end
   end