alchemy_cms 5.2.0 → 6.0.0.b3

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

@@ -0,0 +1,184 @@
+# 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
+
+      # The value of an ingredient of the element by role
+      def value_for(role)
+        ingredient_by_role(role)&.value
+      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)
+        value_for(role).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
+        ingredient_definitions.each do |attributes|
+          ingredients.build(
+            role: attributes[:role],
+            type: Alchemy::Ingredient.normalize_type(attributes[:type]),
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -1,108 +1,127 @@
 # 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_ingredient(maxlength) ||
+          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
+      # 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 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
+      # Returns a dom id used for elements html id tag.
+      #
+      def dom_id
+        "#{name}_#{id}"
+      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
+      # 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
 
-    # Returns a dom id used for elements html id tag.
-    #
-    def dom_id
-      "#{name}_#{id}"
-    end
+      # The ingredient that's used for element's preview text.
+      #
+      # It tries to find one of element's ingredients that is defined +as_element_title+.
+      # Takes element's first ingredient if no ingredient is defined +as_element_title+.
+      #
+      # @return (Alchemy::Ingredient)
+      #
+      def preview_ingredient
+        @_preview_ingredient ||= ingredients.detect(&:preview_ingredient?) || ingredients.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)
+      end
 
-    def preview_text_from_preview_content(maxlength)
-      preview_content.try!(:preview_text, maxlength)
+      def preview_text_from_preview_ingredient(maxlength)
+        preview_ingredient&.preview_text(maxlength)
+      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