alchemy_cms 5.2.4 → 6.0.0.b1

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

@@ -1,151 +1,160 @@
 # frozen_string_literal: true
 
-# Methods concerning contents for elements
-#
 module Alchemy
-  module Element::ElementContents
-    # Find first content from element by given name.
-    def content_by_name(name)
-      contents_by_name(name).first
-    end
+  class Element < BaseRecord
+    # Methods concerning contents for elements
+    #
+    module ElementContents
+      # Find first content from element by given name.
+      def content_by_name(name)
+        contents_by_name(name).first
+      end
 
-    # Find first content from element by given essence type.
-    def content_by_type(essence_type)
-      contents_by_type(essence_type).first
-    end
+      # Find first content from element by given essence type.
+      def content_by_type(essence_type)
+        contents_by_type(essence_type).first
+      end
 
-    # All contents from element by given name.
-    def contents_by_name(name)
-      contents.select { |content| content.name == name.to_s }
-    end
-    alias_method :all_contents_by_name, :contents_by_name
+      # All contents from element by given name.
+      def contents_by_name(name)
+        contents.select { |content| content.name == name.to_s }
+      end
+
+      alias_method :all_contents_by_name, :contents_by_name
 
-    # All contents from element by given essence type.
-    def contents_by_type(essence_type)
-      contents.select do |content|
-        content.essence_type == Content.normalize_essence_type(essence_type)
+      # All contents from element by given essence type.
+      def contents_by_type(essence_type)
+        contents.select do |content|
+          content.essence_type == Content.normalize_essence_type(essence_type)
+        end
       end
-    end
-    alias_method :all_contents_by_type, :contents_by_type
 
-    # 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 +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?
+      alias_method :all_contents_by_type, :contents_by_type
+
+      # 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 +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.to_s] || next
+          content.update_essence(content_hash) || errors.add(:base, :essence_validation_failed)
+        end
+        errors.blank?
+      end
 
-      contents.each do |content|
-        content_hash = contents_attributes[content.id.to_s] || next
-        content.update_essence(content_hash) || errors.add(:base, :essence_validation_failed)
+      # Copy current content's contents to given target element
+      def copy_contents_to(element)
+        contents.map do |content|
+          Content.copy(content, element_id: element.id)
+        end
       end
-      errors.blank?
-    end
 
-    # Copy current content's contents to given target element
-    def copy_contents_to(element)
-      contents.map do |content|
-        Content.copy(content, element_id: element.id)
+      # 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
-    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 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_definitions
+        return nil if definition.blank?
 
-    # Returns the array with the hashes for all element contents in the elements.yml file
-    def content_definitions
-      return nil if definition.blank?
+        definition["contents"]
+      end
 
-      definition["contents"]
-    end
+      # Returns the definition for given content_name
+      def content_definition_for(content_name)
+        if content_definitions.blank?
+          log_warning "Element #{name} is missing the content definition for #{content_name}"
+          nil
+        else
+          content_definitions.detect { |d| d["name"] == content_name.to_s }
+        end
+      end
 
-    # Returns the definition for given content_name
-    def content_definition_for(content_name)
-      if content_definitions.blank?
-        log_warning "Element #{name} is missing the content definition for #{content_name}"
-        nil
-      else
-        content_definitions.detect { |d| d["name"] == content_name.to_s }
+      # Returns an array of all EssenceRichtext contents ids from elements
+      #
+      # This is used to re-initialize the TinyMCE editor in the element editor.
+      #
+      def richtext_contents_ids
+        # This is not very efficient SQL wise I know, but we need to iterate
+        # recursivly through all descendent elements and I don't know how to do this
+        # in pure SQL. Anyone with a better idea is welcome to submit a patch.
+        ids = contents.select(&:has_tinymce?).collect(&:id)
+        expanded_nested_elements = nested_elements.expanded
+        if expanded_nested_elements.present?
+          ids += expanded_nested_elements.collect(&:richtext_contents_ids)
+        end
+        ids.flatten
       end
-    end
 
-    # Returns an array of all EssenceRichtext contents ids from elements
-    #
-    # This is used to re-initialize the TinyMCE editor in the element editor.
-    #
-    def richtext_contents_ids
-      # This is not very efficient SQL wise I know, but we need to iterate
-      # recursivly through all descendent elements and I don't know how to do this
-      # in pure SQL. Anyone with a better idea is welcome to submit a patch.
-      ids = contents.select(&:has_tinymce?).collect(&:id)
-      expanded_nested_elements = nested_elements.expanded
-      if expanded_nested_elements.present?
-        ids += expanded_nested_elements.collect(&:richtext_contents_ids)
+      # True, if any of the element's contents has essence validations defined.
+      def has_validations?
+        !contents.detect(&:has_validations?).blank?
       end
-      ids.flatten
-    end
 
-    # True, if any of the element's contents has essence validations defined.
-    def has_validations?
-      !contents.detect(&:has_validations?).blank?
-    end
+      # All element contents where the essence validation has failed.
+      def contents_with_errors
+        contents.select(&:essence_validation_failed?)
+      end
 
-    # All element contents where the essence validation has failed.
-    def contents_with_errors
-      contents.select(&:essence_validation_failed?)
-    end
+      private
 
-    private
+      def content_for_rss_meta(type)
+        definition = content_definitions.detect { |c| c["rss_#{type}"] }
+        return if definition.blank?
 
-    def content_for_rss_meta(type)
-      definition = content_definitions.detect { |c| c["rss_#{type}"] }
-      return if definition.blank?
+        contents.detect { |content| content.name == definition["name"] }
+      end
 
-      contents.detect { |content| content.name == definition["name"] }
-    end
+      # creates the contents for this element as described in the elements.yml
+      #
+      # If ingredients are defined as well no contents get created,
+      # ingredients get created instead.
+      def create_contents
+        return if definition.fetch(:ingredients, []).any?
 
-    # creates the contents for this element as described in the elements.yml
-    def create_contents
-      definition.fetch("contents", []).each do |attributes|
-        Content.create(attributes.merge(element: self))
+        definition.fetch("contents", []).each do |attributes|
+          Content.create(attributes.merge(element: self))
+        end
       end
     end
   end

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

@@ -1,112 +1,114 @@
 # frozen_string_literal: true
 
 module Alchemy
-  module Element::ElementEssences
-    # Returns the contents essence value (aka. ingredient) for passed content name.
-    def ingredient(name)
-      content = content_by_name(name)
-      return nil if content.blank?
+  class Element < BaseRecord
+    module ElementEssences
+      # Returns the contents essence value (aka. ingredient) for passed content name.
+      def ingredient(name)
+        content = content_by_name(name)
+        return nil if content.blank?
 
-      content.ingredient
-    end
+        content.ingredient
+      end
 
-    # True if the element has a content for given name,
-    # that has an essence value (aka. ingredient) that is not blank.
-    def has_ingredient?(name)
-      ingredient(name).present?
-    end
+      # True if the element has a content for given name,
+      # that has an essence value (aka. ingredient) that is not blank.
+      def has_ingredient?(name)
+        ingredient(name).present?
+      end
 
-    # Returns all essence errors in the format of:
-    #
-    #   {
-    #     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 = {}
-      contents.each do |content|
-        if content.essence_validation_failed?
-          essence_errors[content.name] = content.essence.validation_errors
+      # Returns all essence errors in the format of:
+      #
+      #   {
+      #     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 = {}
+        contents.each do |content|
+          if content.essence_validation_failed?
+            essence_errors[content.name] = content.essence.validation_errors
+          end
         end
+        essence_errors
       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 << Alchemy.t(
-            "#{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),
-          )
+      # 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 << Alchemy.t(
+              "#{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
-      messages
     end
   end
 end

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

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class Element < BaseRecord
+    # Methods concerning ingredients for elements
+    #
+    module ElementIngredients
+      extend ActiveSupport::Concern
+
+      included do
+        attr_accessor :autogenerate_ingredients
+
+        has_many :ingredients,
+          class_name: "Alchemy::Ingredient",
+          inverse_of: :element,
+          dependent: :destroy
+
+        before_create :build_ingredients,
+          unless: -> { autogenerate_ingredients == false }
+
+        accepts_nested_attributes_for :ingredients
+        validates_associated :ingredients, on: :update
+      end
+
+      # Find first ingredient from element by given role.
+      def ingredient_by_role(role)
+        ingredients.detect { |ingredient| ingredient.role == role.to_s }
+      end
+
+      # Find first ingredient from element by given type.
+      def ingredient_by_type(type)
+        ingredients_by_type(type).first
+      end
+
+      # All ingredients from element by given type.
+      def ingredients_by_type(type)
+        ingredients.select do |ingredient|
+          ingredient.type == Ingredient.normalize_type(type)
+        end
+      end
+
+      # Copy current ingredient's ingredients to given target element
+      def copy_ingredients_to(element)
+        ingredients.map do |ingredient|
+          Ingredient.copy(ingredient, element_id: element.id)
+        end
+      end
+
+      # Returns all element ingredient definitions from the +elements.yml+ file
+      def ingredient_definitions
+        definition.fetch(:ingredients, [])
+      end
+
+      # Returns the definition for given ingredient role
+      def ingredient_definition_for(role)
+        if ingredient_definitions.blank?
+          log_warning "Element #{name} is missing the ingredient definition for #{role}"
+          nil
+        else
+          ingredient_definitions.find { |d| d[:role] == role.to_s }
+        end
+      end
+
+      # Returns an array of all Richtext ingredients ids from elements
+      #
+      # This is used to re-initialize the TinyMCE editor in the element editor.
+      #
+      def richtext_ingredients_ids
+        ids = ingredients.select(&:has_tinymce?).collect(&:id)
+        expanded_nested_elements = nested_elements.expanded
+        if expanded_nested_elements.present?
+          ids += expanded_nested_elements.collect(&:richtext_ingredients_ids)
+        end
+        ids.flatten
+      end
+
+      # Has any of the ingredients validations defined?
+      def has_validations?
+        ingredients.any?(&:has_validations?)
+      end
+
+      # All element ingredients where the validation has failed.
+      def ingredients_with_errors
+        ingredients.select { |i| i.errors.any? }
+      end
+
+      # True if the element has a ingredient for given name
+      # that has a non blank value.
+      def has_value_for?(role)
+        ingredient_by_role(role)&.value.present?
+      end
+
+      # Ingredient validation error messages
+      #
+      # == Error messages are translated via I18n
+      #
+      # Inside your translation file add translations like:
+      #
+      #   alchemy:
+      #     ingredient_validations:
+      #       name_of_the_element:
+      #         role_of_the_ingredient:
+      #           validation_error_type: Error Message
+      #
+      # NOTE: +validation_error_type+ has to be one of:
+      #
+      #   * blank
+      #   * taken
+      #   * invalid
+      #
+      # === Example:
+      #
+      #   de:
+      #     alchemy:
+      #       ingredient_validations:
+      #         contactform:
+      #           email:
+      #             invalid: 'Die Email hat nicht das richtige Format'
+      #
+      #
+      # == Error message translation fallbacks
+      #
+      # In order to not translate every single ingredient for every element
+      # you can provide default error messages per content name:
+      #
+      # === Example
+      #
+      #   en:
+      #     alchemy:
+      #       ingredient_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:
+      #       ingredient_validations:
+      #         errors:
+      #           invalid: %{field} has wrong format
+      #           blank: %{field} can't be blank
+      #
+      def ingredient_error_messages
+        messages = []
+        ingredients_with_errors.map { |i| [i.role, i.errors.details] }.each do |role, error_details|
+          error_details[:value].each do |error_detail|
+            error = error_detail[:error]
+            messages << Alchemy.t(
+              "#{name}.#{role}.#{error}",
+              scope: "ingredient_validations",
+              default: [
+                "fields.#{role}.#{error}".to_sym,
+                "errors.#{error}".to_sym,
+              ],
+              field: Alchemy::Ingredient.translated_label_for(role, name),
+            )
+          end
+        end
+        messages
+      end
+
+      private
+
+      # Builds ingredients for this element as described in the +elements.yml+
+      def build_ingredients
+        self.ingredients = ingredient_definitions.map do |attributes|
+          Ingredient.build(role: attributes[:role], element: self)
+        end
+      end
+    end
+  end
+end