alchemy_cms 3.2.1 → 3.3.0.rc1

data/app/models/alchemy/element.rb

@@ -23,30 +23,67 @@ module Alchemy
     include Alchemy::Touching
     include Alchemy::Hints
 
-    FORBIDDEN_DEFINITION_ATTRIBUTES = %w(contents available_contents amount picture_gallery taggable hint)
-    SKIPPED_ATTRIBUTES_ON_COPY = %w(id position folded created_at updated_at creator_id updater_id cached_tag_list)
+    FORBIDDEN_DEFINITION_ATTRIBUTES = [
+      "amount",
+      "nestable_elements",
+      "contents",
+      "hint",
+      "picture_gallery",
+      "taggable"
+    ].freeze
+
+    SKIPPED_ATTRIBUTES_ON_COPY = [
+      "cached_tag_list",
+      "created_at",
+      "creator_id",
+      "id",
+      "folded",
+      "position",
+      "updated_at",
+      "updater_id"
+    ].freeze
 
     acts_as_taggable
 
-    # All Elements inside a cell are a list. All Elements not in cell are in the cell_id.nil list.
-    acts_as_list scope: [:page_id, :cell_id]
+    # All Elements that share the same page id, cell id and parent element id are considered a list.
+    #
+    # If cell id and parent element id are 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 cell_id = NULL AND parent_element_id = NULL
+    #
+    acts_as_list scope: [:page_id, :cell_id, :parent_element_id]
+
     stampable stamper_class_name: Alchemy.user_class_name
 
     has_many :contents, -> { order(:position) }, dependent: :destroy
+
+    # Elements can have other elements nested inside
+    has_many :nested_elements,
+      -> { order(:position).not_trashed },
+      class_name: 'Alchemy::Element',
+      foreign_key: :parent_element_id,
+      dependent: :destroy
+
     belongs_to :cell
     belongs_to :page
+
+    # A nested element belongs to a parent element.
+    belongs_to :parent_element, class_name: 'Alchemy::Element', touch: true
+
     has_and_belongs_to_many :touchable_pages, -> { uniq },
       class_name: 'Alchemy::Page',
       join_table: ElementToPage.table_name
 
-    validates_presence_of :name, :on => :create
-    validates_format_of :name, :on => :create, :with => /\A[a-z0-9_-]+\z/
+    validates_presence_of :name, on: :create
+    validates_format_of :name, on: :create, with: /\A[a-z0-9_-]+\z/
 
     attr_accessor :create_contents_after_create
 
-    after_create :create_contents, :unless => proc { |e| e.create_contents_after_create == false }
+    after_create :create_contents, unless: proc { |e| e.create_contents_after_create == false }
     after_update :touch_pages
-    after_update :touch_cell, unless: -> { self.cell.nil? }
+    after_update :touch_cell, unless: -> { cell.nil? }
 
     scope :trashed,           -> { where(position: nil).order('updated_at DESC') }
     scope :not_trashed,       -> { where(Element.arel_table[:position].not_eq(nil)) }
@@ -56,18 +93,21 @@ module Alchemy
     scope :named,             ->(names) { where(name: names) }
     scope :excluded,          ->(names) { where(arel_table[:name].not_in(names)) }
     scope :not_in_cell,       -> { where(cell_id: nil) }
-    scope :in_cell,           -> { where("#{self.table_name}.cell_id IS NOT NULL") }
+    scope :in_cell,           -> { where("#{table_name}.cell_id IS NOT NULL") }
     scope :from_current_site, -> { where(Language.table_name => {site_id: Site.current || Site.default}).joins(page: 'language') }
+    scope :folded,            -> { where(folded: true) }
+    scope :expanded,          -> { where(folded: false) }
 
     delegate :restricted?, to: :page, allow_nil: true
 
     # Concerns
     include Alchemy::Element::Definitions
+    include Alchemy::Element::ElementContents
+    include Alchemy::Element::ElementEssences
     include Alchemy::Element::Presenters
 
     # class methods
     class << self
-
       # Builds a new element as described in +/config/alchemy/elements.yml+
       #
       # - Returns a new Alchemy::Element object if no name is given in attributes,
@@ -77,11 +117,9 @@ module Alchemy
       #
       def new_from_scratch(attributes = {})
         attributes = attributes.dup.symbolize_keys
-
         return new if attributes[:name].blank?
 
-        new_element_from_definition_by(attributes) ||
-          raise(ElementDefinitionError.new(attributes))
+        new_element_from_definition_by(attributes) || raise(ElementDefinitionError, attributes)
       end
 
       # Creates a new element as described in +/config/alchemy/elements.yml+
@@ -105,20 +143,32 @@ module Alchemy
       #
       # == Example
       #
-      #   @copy = Alchemy::Element.copy(@element, {:public => false})
+      #   @copy = Alchemy::Element.copy(@element, {public: false})
       #   @copy.public? # => false
       #
-      def copy(source, differences = {})
-        source.attributes.stringify_keys!
+      def copy(source_element, differences = {})
+        source_element.attributes.stringify_keys!
         differences.stringify_keys!
-        attributes = source.attributes.except(*SKIPPED_ATTRIBUTES_ON_COPY).merge(differences)
-        element = self.create!(attributes.merge(:create_contents_after_create => false))
-        element.tag_list = source.tag_list
-        source.contents.each do |content|
-          new_content = Content.copy(content, :element_id => element.id)
-          new_content.move_to_bottom
+
+        attributes = source_element.attributes
+                       .except(*SKIPPED_ATTRIBUTES_ON_COPY)
+                       .merge(differences)
+                       .merge({
+                         create_contents_after_create: false,
+                         tag_list: source_element.tag_list
+                       })
+
+        new_element = create!(attributes)
+
+        if source_element.contents.any?
+          source_element.copy_contents_to(new_element)
         end
-        element
+
+        if source_element.nested_elements.any?
+          source_element.copy_nested_elements_to(new_element)
+        end
+
+        new_element
       end
 
       def all_from_clipboard(clipboard)
@@ -140,10 +190,10 @@ module Alchemy
       def new_element_from_definition_by(attributes)
         remove_cell_name_from_element_name!(attributes)
 
-        element_scratch = definitions.detect { |el| el['name'] == attributes[:name] }
-        return if element_scratch.nil?
+        element_definition = Element.definition_by_name(attributes[:name])
+        return if element_definition.nil?
 
-        new(element_scratch.merge(attributes).except(*FORBIDDEN_DEFINITION_ATTRIBUTES))
+        new(element_definition.merge(attributes).except(*FORBIDDEN_DEFINITION_ATTRIBUTES))
       end
 
       def remove_cell_name_from_element_name!(attributes)
@@ -170,9 +220,9 @@ module Alchemy
     # Stores the page into +touchable_pages+ (Pages that have to be touched after updating the element).
     def store_page(page)
       return true if page.nil?
-      unless self.touchable_pages.include? page
-        self.touchable_pages << page
-        self.save
+      unless touchable_pages.include? page
+        touchable_pages << page
+        save
       end
     end
 
@@ -180,229 +230,11 @@ module Alchemy
     def trash!
       self.public = false
       self.folded = true
-      self.remove_from_list
+      remove_from_list
     end
 
     def trashed?
-      self.position.nil?
-    end
-
-    def content_by_name(name)
-      self.contents.find_by_name(name)
-    end
-
-    def content_by_type(essence_type)
-      self.contents.find_by_essence_type(Content.normalize_essence_type(essence_type))
-    end
-
-    def all_contents_by_name(name)
-      self.contents.where(:name => name)
-    end
-
-    def all_contents_by_type(essence_type)
-      self.contents.where(:essence_type => Content.normalize_essence_type(essence_type))
-    end
-
-    # Returns the content that is marked as rss title.
-    #
-    # Mark a content as rss title in your +elements.yml+ file:
-    #
-    #   - name: news
-    #     contents:
-    #     - name: headline
-    #       type: EssenceText
-    #       rss_title: true
-    #
-    def content_for_rss_title
-      content_for_rss_meta('title')
-    end
-
-    # Returns the content that is marked as rss description.
-    #
-    # Mark a content as rss description in your +elements.yml+ file:
-    #
-    #   - name: news
-    #     contents:
-    #     - name: body
-    #       type: EssenceRichtext
-    #       rss_description: true
-    #
-    def content_for_rss_description
-      content_for_rss_meta('description')
-    end
-
-    # Returns the array with the hashes for all element contents in the elements.yml file
-    def content_descriptions
-      return nil if definition.blank?
-      definition['contents']
-    end
-
-    # Returns the definition for given content_name
-    def content_description_for(content_name)
-      if content_descriptions.blank?
-        log_warning "Element #{self.name} is missing the content definition for #{content_name}"
-        return nil
-      else
-        content_descriptions.detect { |d| d['name'] == content_name }
-      end
-    end
-
-    # Returns the definition for given content_name inside the available_contents
-    def available_content_description_for(content_name)
-      return nil if available_contents.blank?
-      available_contents.detect { |d| d['name'] == content_name }
-    end
-
-    # returns the collection of available essence_types that can be created for this element depending on its description in elements.yml
-    def available_contents
-      definition['available_contents']
-    end
-
-    # Returns the contents ingredient for passed content name.
-    def ingredient(name)
-      content = content_by_name(name)
-      return nil if content.blank?
-      content.ingredient
-    end
-
-    def has_ingredient?(name)
-      self.ingredient(name).present?
-    end
-
-    # Updates all related contents by calling +update_essence+ on each of them.
-    #
-    # @param contents_attributes [Hash]
-    #   Hash of contents attributes.
-    #   The keys has to be the #id of the content to update.
-    #   The values a Hash of attribute names and values
-    #
-    # @return [Boolean]
-    #   True if +self.errors+ are blank or +contents_attributes+ hash is nil
-    #
-    # == Example
-    #
-    #   @element.update_contents({1 => {ingredient: 'Title'}, 2 => {link: 'https://google.com'}})
-    #
-    def update_contents(contents_attributes)
-      return true if contents_attributes.nil?
-      contents.each do |content|
-        content_hash = contents_attributes["#{content.id}"] || next
-        content.update_essence(content_hash) || errors.add(:base, :essence_validation_failed)
-      end
-      errors.blank?
-    end
-
-    def essences
-      return [] if contents.blank?
-      contents.collect(&:essence)
-    end
-
-    # Returns all essence_errors in the format:
-    #
-    #   {
-    #     essence.content.name => [error_message_for_validation_1, error_message_for_validation_2]
-    #   }
-    #
-    # Get translated error messages with Element#essence_error_messages
-    #
-    def essence_errors
-      essence_errors = {}
-      essences.each do |essence|
-        unless essence.errors.blank?
-          essence_errors[essence.content.name] = essence.validation_errors
-        end
-      end
-      essence_errors
-    end
-
-    # Essence validation errors
-    #
-    # == Error messages are translated via I18n
-    #
-    # Inside your translation file add translations like:
-    #
-    #   alchemy:
-    #     content_validations:
-    #       name_of_the_element:
-    #         name_of_the_content:
-    #           validation_error_type: Error Message
-    #
-    # NOTE: +validation_error_type+ has to be one of:
-    #
-    #   * blank
-    #   * taken
-    #   * invalid
-    #
-    # === Example:
-    #
-    #   de:
-    #     alchemy:
-    #       content_validations:
-    #         contactform:
-    #           email:
-    #             invalid: 'Die Email hat nicht das richtige Format'
-    #
-    #
-    # == Error message translation fallbacks
-    #
-    # In order to not translate every single content for every element you can provide default error messages per content name:
-    #
-    # === Example
-    #
-    #   en:
-    #     alchemy:
-    #       content_validations:
-    #         fields:
-    #           email:
-    #             invalid: E-Mail has wrong format
-    #             blank: E-Mail can't be blank
-    #
-    # And even further you can provide general field agnostic error messages:
-    #
-    # === Example
-    #
-    #   en:
-    #     alchemy:
-    #       content_validations:
-    #         errors:
-    #           invalid: %{field} has wrong format
-    #           blank: %{field} can't be blank
-    #
-    def essence_error_messages
-      messages = []
-      essence_errors.each do |content_name, errors|
-        errors.each do |error|
-          messages << I18n.t(
-            "#{self.name}.#{content_name}.#{error}",
-            scope: 'content_validations',
-            default: [
-              "fields.#{content_name}.#{error}".to_sym,
-              "errors.#{error}".to_sym
-            ],
-            field: Content.translated_label_for(content_name, name)
-          )
-        end
-      end
-      messages
-    end
-
-    def contents_with_errors
-      contents.select(&:essence_validation_failed?)
-    end
-
-    def has_validations?
-      !contents.detect(&:has_validations?).blank?
-    end
-
-    def rtf_contents
-      contents.essence_richtexts
-    end
-    alias_method :richtext_contents, :rtf_contents
-
-    # Returns an array of all EssenceRichtext contents ids
-    #
-    def richtext_contents_ids
-      contents.essence_richtexts.pluck("#{Content.table_name}.id")
+      position.nil?
     end
 
     # The names of all cells from given page this element could be placed in.
@@ -421,6 +253,11 @@ module Alchemy
       definition['taggable'] == true
     end
 
+    # The opposite of folded?
+    def expanded?
+      !folded?
+    end
+
     # The element's view partial is dependent from its name
     #
     # == Define elements
@@ -453,26 +290,24 @@ module Alchemy
       end
     end
 
-    private
-
-    def content_for_rss_meta(type)
-      description = content_descriptions.detect { |c| c["rss_#{type}"] }
-      return if description.blank?
-      contents.find_by(name: description['name'])
+    # A collection of element names that can be nested inside this element.
+    def nestable_elements
+      definition.fetch('nestable_elements', [])
     end
 
-    # creates the contents for this element as described in the elements.yml
-    def create_contents
-      contents = []
-      if definition["contents"].blank?
-        log_warning "Could not find any content descriptions for element: #{self.name}"
-      else
-        definition["contents"].each do |content_hash|
-          contents << Content.create_from_scratch(self, content_hash.symbolize_keys)
-        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,
+          cell_id: target_element.cell_id
+        })
       end
     end
 
+    private
+
     # Returns previous or next public element from same page.
     #
     # @param [String]
@@ -490,7 +325,7 @@ module Alchemy
     #
     def available_page_cells(page)
       page.cells.select do |cell|
-        cell.available_elements.include?(self.name)
+        cell.available_elements.include?(name)
       end
     end
 
@@ -506,8 +341,7 @@ module Alchemy
     # Called after_update
     #
     def touch_cell
-      self.cell.touch
+      cell.touch
     end
-
   end
 end