alchemy_cms 5.2.4 → 6.0.0.b1

data/app/models/alchemy/element/presenters.rb

@@ -1,108 +1,110 @@
 # frozen_string_literal: true
 
 module Alchemy
-  # Methods used for presenting an Alchemy Element.
-  #
-  module Element::Presenters
-    extend ActiveSupport::Concern
+  class Element < BaseRecord
+    # Methods used for presenting an Alchemy Element.
+    #
+    module Presenters
+      extend ActiveSupport::Concern
+
+      module ClassMethods
+        # Human name for displaying elements in select boxes and element editor views.
+        #
+        # The name is beeing translated from given name value as described in +config/alchemy/elements.yml+
+        #
+        # Translate the name in your +config/locales+ language file.
+        #
+        # == Example:
+        #
+        #   de:
+        #     alchemy:
+        #       element_names:
+        #         contactform: 'Kontakt Formular'
+        #
+        # If no translation is found a humanized name is used.
+        #
+        def display_name_for(name)
+          Alchemy.t(name, scope: "element_names", default: name.to_s.humanize)
+        end
+      end
 
-    module ClassMethods
-      # Human name for displaying elements in select boxes and element editor views.
+      # Returns the translated name
       #
-      # The name is beeing translated from given name value as described in +config/alchemy/elements.yml+
+      # @see Alchemy::Element::Presenters#display_name_for
       #
-      # Translate the name in your +config/locales+ language file.
+      def display_name
+        self.class.display_name_for(definition["name"] || name)
+      end
+
+      # Returns a preview text for element.
       #
-      # == Example:
+      # It's taken from the first Content found in the +elements.yml+ definition file.
       #
-      #   de:
-      #     alchemy:
-      #       element_names:
-      #         contactform: 'Kontakt Formular'
+      # You can flag a Content as +as_element_title+ to take this as preview.
       #
-      # If no translation is found a humanized name is used.
+      # @param maxlength [Fixnum] (60)
+      #   Length of characters after the text will be cut off.
       #
-      def display_name_for(name)
-        Alchemy.t(name, scope: "element_names", default: name.to_s.humanize)
+      def preview_text(maxlength = 60)
+        preview_text_from_preview_content(maxlength) || preview_text_from_nested_elements(maxlength)
       end
-    end
 
-    # Returns the translated name
-    #
-    # @see Alchemy::Element::Presenters#display_name_for
-    #
-    def display_name
-      self.class.display_name_for(definition["name"] || name)
-    end
-
-    # Returns a preview text for element.
-    #
-    # It's taken from the first Content found in the +elements.yml+ definition file.
-    #
-    # You can flag a Content as +as_element_title+ to take this as preview.
-    #
-    # @param maxlength [Fixnum] (60)
-    #   Length of characters after the text will be cut off.
-    #
-    def preview_text(maxlength = 60)
-      preview_text_from_preview_content(maxlength) || preview_text_from_nested_elements(maxlength)
-    end
-
-    # Generates a preview text containing Element#display_name and Element#preview_text.
-    #
-    # It is displayed inside the head of the Element in the Elements.list overlay window from the Alchemy Admin::Page#edit view.
-    #
-    # === Example
-    #
-    # A Element described as:
-    #
-    #     - name: funky_element
-    #       display_name: Funky Element
-    #       contents:
-    #       - name: headline
-    #         type: EssenceText
-    #       - name: text
-    #         type EssenceRichtext
-    #         as_element_title: true
-    #
-    # With "I want to tell you a funky story" as stripped_body for the EssenceRichtext Content produces:
-    #
-    #     Funky Element: I want to tell ...
-    #
-    # @param maxlength [Fixnum] (30)
-    #   Length of characters after the text will be cut off.
-    #
-    def display_name_with_preview_text(maxlength = 30)
-      "#{display_name}: #{preview_text(maxlength)}"
-    end
+      # Generates a preview text containing Element#display_name and Element#preview_text.
+      #
+      # It is displayed inside the head of the Element in the Elements.list overlay window from the Alchemy Admin::Page#edit view.
+      #
+      # === Example
+      #
+      # A Element described as:
+      #
+      #     - name: funky_element
+      #       display_name: Funky Element
+      #       contents:
+      #       - name: headline
+      #         type: EssenceText
+      #       - name: text
+      #         type EssenceRichtext
+      #         as_element_title: true
+      #
+      # With "I want to tell you a funky story" as stripped_body for the EssenceRichtext Content produces:
+      #
+      #     Funky Element: I want to tell ...
+      #
+      # @param maxlength [Fixnum] (30)
+      #   Length of characters after the text will be cut off.
+      #
+      def display_name_with_preview_text(maxlength = 30)
+        "#{display_name}: #{preview_text(maxlength)}"
+      end
 
-    # Returns a dom id used for elements html id tag.
-    #
-    def dom_id
-      "#{name}_#{id}"
-    end
+      # Returns a dom id used for elements html id tag.
+      #
+      def dom_id
+        "#{name}_#{id}"
+      end
 
-    # The content that's used for element's preview text.
-    #
-    # It tries to find one of element's contents that is defined +as_element_title+.
-    # Takes element's first content if no content is defined +as_element_title+.
-    #
-    # @return (Alchemy::Content)
-    #
-    def preview_content
-      @_preview_content ||= contents.detect(&:preview_content?) || contents.first
-    end
+      # The content that's used for element's preview text.
+      #
+      # It tries to find one of element's contents that is defined +as_element_title+.
+      # Takes element's first content if no content is defined +as_element_title+.
+      #
+      # @return (Alchemy::Content)
+      #
+      def preview_content
+        @_preview_content ||= contents.detect(&:preview_content?) || contents.first
+      end
 
-    private
+      private
 
-    def preview_text_from_nested_elements(maxlength)
-      return if all_nested_elements.empty?
+      def preview_text_from_nested_elements(maxlength)
+        return if all_nested_elements.empty?
 
-      all_nested_elements.first.preview_text(maxlength)
-    end
+        all_nested_elements.first.preview_text(maxlength)
+      end
 
-    def preview_text_from_preview_content(maxlength)
-      preview_content.try!(:preview_text, maxlength)
+      def preview_text_from_preview_content(maxlength)
+        preview_content.try!(:preview_text, maxlength)
+      end
     end
   end
 end

data/app/models/alchemy/element.rb

@@ -7,7 +7,7 @@
 #  id                :integer          not null, primary key
 #  name              :string
 #  position          :integer
-#  page_id           :integer          not null
+#  page_version_id   :integer          not null
 #  public            :boolean          default(TRUE)
 #  fixed             :boolean          default(FALSE)
 #  folded            :boolean          default(FALSE)
@@ -20,6 +20,12 @@
 #  parent_element_id :integer
 #
 
+require_dependency "alchemy/element/definitions"
+require_dependency "alchemy/element/element_contents"
+require_dependency "alchemy/element/element_ingredients"
+require_dependency "alchemy/element/element_essences"
+require_dependency "alchemy/element/presenters"
+
 module Alchemy
   class Element < BaseRecord
     NAME_REGEXP = /\A[a-z0-9_-]+\z/
@@ -34,39 +40,31 @@ module Alchemy
       "nestable_elements",
       "contents",
       "hint",
+      "ingredients",
       "taggable",
       "compact",
       "message",
       "deprecated",
     ].freeze
 
-    SKIPPED_ATTRIBUTES_ON_COPY = [
-      "cached_tag_list",
-      "created_at",
-      "creator_id",
-      "id",
-      "folded",
-      "position",
-      "updated_at",
-      "updater_id",
-    ].freeze
-
-    # All Elements that share the same page id and parent element id and are fixed or not are considered a list.
+    # All Elements that share the same page version and parent element and are fixed or not are considered a list.
     #
-    # If parent element id is nil (typical case for a simple page),
+    # If parent_element_id is nil (typical case for a simple page),
     # then all elements on that page are still in one list,
     # because acts_as_list correctly creates this statement:
     #
-    #   WHERE page_id = 1 and fixed = FALSE AND parent_element_id = NULL
+    #   WHERE page_version_id = 1 and fixed = FALSE AND parent_element_id = NULL
     #
-    acts_as_list scope: [:page_id, :fixed, :parent_element_id]
+    acts_as_list scope: [:page_version_id, :fixed, :parent_element_id]
 
-    stampable stamper_class_name: Alchemy.user_class.name
+    stampable stamper_class_name: Alchemy.user_class_name
 
     has_many :contents, dependent: :destroy, inverse_of: :element
 
+    before_destroy :delete_all_nested_elements
+
     has_many :all_nested_elements,
-      -> { order(:position).not_trashed },
+      -> { order(:position) },
       class_name: "Alchemy::Element",
       foreign_key: :parent_element_id,
       dependent: :destroy
@@ -78,7 +76,8 @@ module Alchemy
       dependent: :destroy,
       inverse_of: :parent_element
 
-    belongs_to :page, touch: true, inverse_of: :elements
+    belongs_to :page_version, touch: true, inverse_of: :elements
+    has_one :page, through: :page_version
 
     # A nested element belongs to a parent element.
     belongs_to :parent_element,
@@ -101,11 +100,10 @@ module Alchemy
 
     after_update :touch_touchable_pages
 
-    scope :trashed, -> { where(position: nil).order("updated_at DESC") }
-    scope :not_trashed, -> { where.not(position: nil) }
     scope :published, -> { where(public: true) }
+    scope :hidden, -> { where(public: false) }
     scope :not_restricted, -> { joins(:page).merge(Page.not_restricted) }
-    scope :available, -> { published.not_trashed }
+    scope :available, -> { published }
     scope :named, ->(names) { where(name: names) }
     scope :excluded, ->(names) { where.not(name: names) }
     scope :fixed, -> { where(fixed: true) }
@@ -118,16 +116,14 @@ module Alchemy
     delegate :restricted?, to: :page, allow_nil: true
 
     # Concerns
-    include Alchemy::Element::Definitions
-    include Alchemy::Element::ElementContents
-    include Alchemy::Element::ElementEssences
-    include Alchemy::Element::Presenters
+    include Definitions
+    include ElementContents
+    include ElementEssences
+    include ElementIngredients
+    include Presenters
 
     # class methods
     class << self
-      deprecate :trashed, deprecator: Alchemy::Deprecation
-      deprecate :not_trashed, deprecator: Alchemy::Deprecation
-
       # Builds a new element as described in +/config/alchemy/elements.yml+
       #
       # - Returns a new Alchemy::Element object if no name is given in attributes,
@@ -159,26 +155,7 @@ module Alchemy
       #   @copy.public? # => false
       #
       def copy(source_element, differences = {})
-        attributes = source_element.attributes.with_indifferent_access
-          .except(*SKIPPED_ATTRIBUTES_ON_COPY)
-          .merge(differences)
-          .merge({
-            autogenerate_contents: false,
-            autogenerate_nested_elements: false,
-            tag_list: source_element.tag_list,
-          })
-
-        new_element = create!(attributes)
-
-        if source_element.contents.any?
-          source_element.copy_contents_to(new_element)
-        end
-
-        if source_element.nested_elements.any?
-          source_element.copy_nested_elements_to(new_element)
-        end
-
-        new_element
+        Alchemy::DuplicateElement.new(source_element).call(differences)
       end
 
       def all_from_clipboard(clipboard)
@@ -225,19 +202,6 @@ module Alchemy
       end
     end
 
-    # Trashing an element means nullifying its position, folding and unpublishing it.
-    def trash!
-      self.public = false
-      self.folded = true
-      remove_from_list
-    end
-    deprecate :trash!, deprecator: Alchemy::Deprecation
-
-    def trashed?
-      position.nil?
-    end
-    deprecate :trashed?, deprecator: Alchemy::Deprecation
-
     # Returns true if the definition of this element has a taggable true value.
     def taggable?
       definition["taggable"] == true
@@ -322,22 +286,12 @@ module Alchemy
       definition.fetch("nestable_elements", [])
     end
 
-    # Copy all nested elements from current element to given target element.
-    def copy_nested_elements_to(target_element)
-      nested_elements.map do |nested_element|
-        Element.copy(nested_element, {
-          parent_element_id: target_element.id,
-          page_id: target_element.page_id,
-        })
-      end
-    end
-
     private
 
     def generate_nested_elements
       definition.fetch("autogenerate", []).each do |nestable_element|
         if nestable_elements.include?(nestable_element)
-          Element.create(page: page, parent_element_id: id, name: nestable_element)
+          Element.create(page_version: page_version, parent_element_id: id, name: nestable_element)
         else
           log_warning("Element '#{nestable_element}' not a nestable element for '#{name}'. Skipping!")
         end
@@ -358,5 +312,18 @@ module Alchemy
 
       touchable_pages.each(&:touch)
     end
+
+    def delete_all_nested_elements
+      deeply_nested_elements = descendent_elements(self).flatten
+      DeleteElements.new(deeply_nested_elements).call
+      nested_elements.reset
+      all_nested_elements.reset
+    end
+
+    def descendent_elements(element)
+      element.all_nested_elements + element.all_nested_elements.map do |nested_element|
+        descendent_elements(nested_element)
+      end
+    end
   end
 end

data/app/models/alchemy/elements_repository.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+module Alchemy
+  # Mimics ActiveRecord query interface
+  # but does this on the preloaded elements
+  class ElementsRepository
+    include Enumerable
+
+    # An empty set of elements
+    def self.none
+      new([])
+    end
+
+    # @param [ActiveRecord::Relation]
+    def initialize(elements)
+      @elements = elements.to_a
+    end
+
+    # All visible elements
+    # @return [Alchemy::ElementRepository]
+    def visible
+      self.class.new select(&:public)
+    end
+
+    # All not fixed elements
+    # @return [Alchemy::ElementRepository]
+    def hidden
+      self.class.new reject(&:public)
+    end
+
+    # All elements with given name(s)
+    # @param [Array<String|Symbol>|String|Symbol]
+    # @return [Alchemy::ElementRepository]
+    def named(*names)
+      names.flatten!
+      self.class.new(select { |e| e.name.in?(names.map!(&:to_s)) })
+    end
+
+    # Filter elements by given attribute and value
+    # @param [Array|Hash]
+    # @return [Alchemy::ElementRepository]
+    def where(attrs)
+      self.class.new(
+        select do |element|
+          attrs.all? do |attr, value|
+            element.public_send(attr) == value
+          end
+        end
+      )
+    end
+
+    # All elements excluding those wth given name(s)
+    # @param [Array<String|Symbol>|String|Symbol]
+    # @return [Alchemy::ElementRepository]
+    def excluded(*names)
+      names.flatten!
+      self.class.new(reject { |e| e.name.in?(names.map!(&:to_s)) })
+    end
+
+    # All fixed elements
+    # @return [Alchemy::ElementRepository]
+    def fixed
+      self.class.new select(&:fixed)
+    end
+
+    # All not fixed elements
+    # @return [Alchemy::ElementRepository]
+    def unfixed
+      self.class.new reject(&:fixed)
+    end
+
+    # All folded elements
+    # @return [Alchemy::ElementRepository]
+    def folded
+      self.class.new select(&:folded)
+    end
+
+    # All expanded elements
+    # @return [Alchemy::ElementRepository]
+    def expanded
+      self.class.new reject(&:folded)
+    end
+
+    # All not nested top level elements
+    # @return [Alchemy::ElementRepository]
+    def not_nested
+      self.class.new(select { |e| e.parent_element_id.nil? })
+    end
+
+    # Elements in reversed order
+    # @return [Alchemy::ElementRepository]
+    def reverse
+      self.class.new elements.reverse
+    end
+
+    # Elements in random order
+    # @return [Alchemy::ElementRepository]
+    def random
+      self.class.new Array(elements).shuffle
+    end
+
+    # Elements off setted by
+    # @return [Alchemy::ElementRepository]
+    def offset(offset)
+      self.class.new elements[offset.to_i..-1]
+    end
+
+    # Elements limitted by
+    # @return [Alchemy::ElementRepository]
+    def limit(limit)
+      self.class.new elements[0..(limit.to_i - 1)]
+    end
+
+    def children_of(parent)
+      self.class.new(select { |e| e.parent_element_id == parent.id })
+    end
+
+    def each(&blk)
+      elements.each(&blk)
+    end
+
+    private
+
+    attr_reader :elements
+  end
+end

data/app/models/alchemy/essence_audio.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class EssenceAudio < ActiveRecord::Base
+    acts_as_essence(
+      ingredient_column: :attachment,
+      preview_text_method: :name,
+    )
+
+    belongs_to :attachment, optional: true
+  end
+end

data/app/models/alchemy/essence_headline.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class EssenceHeadline < BaseRecord
+    acts_as_essence
+
+    after_initialize :set_level_and_size
+
+    def preview_text(maxlength = 30)
+      "H#{level}: #{body}"[0..maxlength - 1]
+    end
+
+    def level_options
+      levels.map { |level| ["H#{level}", level] }
+    end
+
+    def size_options
+      sizes.map { |size| ["H#{size}", size] }
+    end
+
+    private
+
+    def content_settings
+      content&.settings || {}
+    end
+
+    def levels
+      content_settings.fetch(:levels, (1..6))
+    end
+
+    def sizes
+      content_settings.fetch(:sizes, [])
+    end
+
+    def set_level_and_size
+      self.level ||= levels.first
+      self.size ||= sizes.first
+    end
+  end
+end