alchemy_cms 8.0.7 → 8.1.1

data/app/components/alchemy/ingredients/base_editor.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    class BaseEditor < ViewComponent::Base
+      delegate :definition,
+        :element,
+        :id,
+        :linked?,
+        :partial_name,
+        :role,
+        :settings,
+        :value,
+        to: :ingredient
+
+      delegate :alchemy,
+        :can?,
+        :cannot?,
+        :dom_id,
+        :hint_with_tooltip,
+        :render_hint_for,
+        :render_icon,
+        :warning,
+        to: :helpers
+
+      attr_reader :ingredient, :html_options
+
+      def initialize(ingredient, html_options: {})
+        raise ArgumentError, "Ingredient missing!" if ingredient.nil?
+
+        @ingredient = ingredient
+        @html_options = html_options
+      end
+
+      def call
+        tag.div(class: css_classes, data: data_attributes, id: dom_id(ingredient)) do
+          concat ingredient_id_field
+          concat ingredient_label
+          concat input_field
+        end
+      end
+
+      # Returns a string to be passed to Rails form field helpers.
+      #
+      # === Example:
+      #
+      #   <%= text_field_tag text_editor.form_field_name, text_editor.value %>
+      #
+      # === Options:
+      #
+      # You can pass an Ingredient column_name. Default is 'value'
+      #
+      # ==== Example:
+      #
+      #   <%= text_field_tag text_editor.form_field_name(:link), text_editor.value %>
+      #
+      def form_field_name(column = "value")
+        "element[ingredients_attributes][#{form_field_counter}][#{column}]"
+      end
+
+      # Returns a unique string to be passed to a form field id.
+      #
+      # @param column [String] A Ingredient column_name. Default is 'value'
+      #
+      def form_field_id(column = "value")
+        "element_#{element.id}_ingredient_#{ingredient.id}_#{column}"
+      end
+
+      private
+
+      def editable?
+        @_editable ||= can?(:edit, ingredient)
+      end
+
+      # Returns the translated role for displaying in labels
+      #
+      # Translate it in your locale yml file:
+      #
+      #   alchemy:
+      #     ingredient_roles:
+      #       foo: Bar
+      #
+      # Optionally you can scope your ingredient role to an element:
+      #
+      #   alchemy:
+      #     ingredient_roles:
+      #       article:
+      #         foo: Baz
+      #
+      def translated_role
+        Alchemy.t(
+          role,
+          scope: "ingredient_roles.#{element.name}",
+          default: Alchemy.t("ingredient_roles.#{role}", default: role.humanize)
+        )
+      end
+
+      def css_classes
+        [
+          "ingredient-editor",
+          partial_name,
+          ingredient.deprecated? ? "deprecated" : nil,
+          settings[:linkable] ? "linkable" : nil,
+          settings[:anchor] ? "with-anchor" : nil
+        ].compact
+      end
+
+      def data_attributes
+        {
+          ingredient_id: ingredient.id,
+          ingredient_role: role
+        }
+      end
+
+      def has_warnings?
+        definition.blank? || ingredient.deprecated?
+      end
+
+      def warnings
+        return unless has_warnings?
+
+        if definition.blank?
+          Logger.warn("ingredient '#{role}' is missing its definition! Please check your element definitions.")
+          Alchemy.t(:ingredient_definition_missing)
+        else
+          definition.deprecation_notice(element_name: element&.name)
+        end
+      end
+
+      def validations
+        definition.validate
+      end
+
+      def format_validation
+        format = validations.select { _1.is_a?(Hash) }.find { _1[:format] }&.fetch(:format)
+        return nil unless format
+
+        # If format is a string or symbol, resolve it from config format_matchers
+        if format.is_a?(String) || format.is_a?(Symbol)
+          Alchemy.config.format_matchers.get(format)
+        else
+          format
+        end
+      end
+
+      def length_validation
+        validations.select { _1.is_a?(Hash) }.find { _1[:length] }&.fetch(:length)
+      end
+
+      def presence_validation?
+        validations.any? do |validation|
+          case validation
+          when :presence, "presence"
+            true
+          when Hash
+            validation[:presence] == true || validation["presence"] == true
+          else
+            false
+          end
+        end
+      end
+
+      def form_field_counter
+        element.definition.ingredients.index { |i| i.role == role }
+      end
+
+      # Renders the translated role of ingredient.
+      #
+      # Displays a warning icon if ingredient is missing its definition.
+      #
+      # Displays a mandatory field indicator, if the ingredient has validations.
+      #
+      def ingredient_role
+        content = translated_role
+
+        if has_warnings?
+          icon = hint_with_tooltip(warnings)
+          content = "#{icon} #{content}".html_safe
+        end
+
+        if ingredient.has_validations?
+          "#{content}<span class='validation_indicator'>*</span>".html_safe
+        else
+          content
+        end
+      end
+
+      # Renders the label and hint for a ingredient.
+      def ingredient_label(column = :value)
+        label_tag form_field_id(column) do
+          concat ingredient_role
+          concat render_hint_for(ingredient, size: "1x", fixed_width: false)
+        end
+      end
+
+      # Renders a hidden field with the ingredient's ID.
+      # This allows Rails to identify which ingredient to update
+      # when processing nested attributes.
+      #
+      def ingredient_id_field
+        hidden_field_tag(form_field_name(:id), ingredient.id, id: nil)
+      end
+
+      # Renders the input field for the ingredient.
+      # Override this method in subclasses to provide custom input fields.
+      # For example a text area or a select box.
+      #
+      def input_field
+        tag.div(class: "input-field") do
+          text_field_tag(form_field_name,
+            value,
+            class: "full_width",
+            id: form_field_id,
+            minlength: length_validation&.fetch(:minimum, nil),
+            maxlength: length_validation&.fetch(:maximum, nil),
+            required: presence_validation?,
+            pattern: format_validation)
+        end
+      end
+    end
+  end
+end

data/app/components/alchemy/ingredients/boolean_editor.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    class BooleanEditor < BaseEditor
+      def call
+        tag.div(class: css_classes, data: data_attributes, id: dom_id(ingredient)) do
+          concat ingredient_id_field
+          concat label_tag(nil, for: form_field_id) {
+            safe_join([
+              hidden_field_tag(form_field_name, "0", id: nil),
+              check_box_tag(form_field_name, "1", value, id: form_field_id, disabled: !editable?),
+              ingredient_role,
+              render_hint_for(ingredient, size: "1x", fixed_width: false)
+            ])
+          }
+        end
+      end
+    end
+  end
+end

data/app/components/alchemy/ingredients/color_editor.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    class ColorEditor < BaseEditor
+      def input_field
+        content_tag("alchemy-color-select") do
+          if colors.none?
+            concat text_field_tag(
+              form_field_name,
+              value,
+              disabled: !editable?
+            )
+            concat color_field_tag(nil, value, disabled: disabled?)
+          else
+            concat select_tag(
+              form_field_name,
+              color_options.join.html_safe,
+              disabled: !editable?
+            )
+            concat color_field_tag(form_field_name, value, disabled: disabled?)
+          end
+        end
+      end
+
+      private
+
+      def color_value
+        @_color_value ||= begin
+          current_value = value.presence || settings[:default]
+          if current_value.present?
+            unknown_color = with_custom_color? && colors.none? { color_settings(_1)[:value] == current_value }
+            unknown_color ? "custom_color" : current_value
+          elsif with_custom_color?
+            "custom_color"
+          end
+        end
+      end
+
+      def color_options
+        colors.map do |color|
+          name, value, swatch = color_settings(color).values_at(:name, :value, :swatch)
+          selected = value == color_value
+          tag.option(name, value:, selected:, data: {swatch:})
+        end.tap do |option_tags|
+          if with_custom_color?
+            option_tags << tag.option(
+              Alchemy.t(:custom_color),
+              value: "custom_color",
+              selected: color_value == "custom_color"
+            )
+          end
+        end
+      end
+
+      def color_settings(color)
+        case color
+        when Hash
+          color.symbolize_keys.tap { |c| c[:swatch] ||= c[:value] }
+        when Array
+          {name: color[0], value: color[1], swatch: color[2] || color[1]}
+        else
+          {name: color, value: color, swatch: color}
+        end
+      end
+
+      def colors
+        @_colors ||= settings.fetch(:colors, [])
+      end
+
+      def with_custom_color?
+        settings[:custom_color]
+      end
+
+      def disabled?
+        !editable? || (color_value != "custom_color" && colors.present?)
+      end
+    end
+  end
+end

data/app/components/alchemy/ingredients/color_view.rb

@@ -0,0 +1,13 @@
+module Alchemy
+  module Ingredients
+    class ColorView < BaseView
+      def call
+        value
+      end
+
+      def render?
+        !value.nil?
+      end
+    end
+  end
+end

data/app/components/alchemy/ingredients/datetime_editor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    class DatetimeEditor < BaseEditor
+      delegate :alchemy_datepicker, to: :helpers
+
+      def input_field
+        tag.div(class: "input-field") do
+          concat alchemy_datepicker(
+            ingredient, :value, {
+              name: form_field_name,
+              id: form_field_id,
+              value: value,
+              type: settings[:input_type],
+              disabled: !editable?
+            }
+          )
+          concat tag.label(
+            render_icon(:calendar),
+            for: form_field_id,
+            class: "ingredient-date--label"
+          )
+        end
+      end
+    end
+  end
+end

data/app/components/alchemy/ingredients/file_editor.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    class FileEditor < BaseEditor
+      delegate :attachment, to: :ingredient
+      delegate :link_to_dialog, to: :helpers
+
+      def input_field
+        content_tag("alchemy-file-editor", class: "file") do
+          concat tag.div(
+            render_icon(attachment&.icon_css_class),
+            class: "file_icon"
+          )
+          concat tag.div(attachment&.name, class: "file_name")
+          if editable?
+            concat link_to(
+              render_icon(:times), "#",
+              class: [
+                "remove_file_link",
+                attachment ? nil : "hidden"
+              ],
+              data: {
+                form_field_id: form_field_id(:attachment_id)
+              }
+            )
+          end
+          concat(
+            tag.div(class: "file_tools") do
+              concat dialog_link
+              concat link_to_dialog(
+                render_icon(:edit),
+                editable? ? alchemy.edit_admin_ingredient_path(ingredient) : nil,
+                {
+                  title: Alchemy.t(:edit_file_properties),
+                  size: "400x215"
+                },
+                title: editable? ? Alchemy.t(:edit_file_properties) : nil
+              )
+            end
+          )
+          concat hidden_field_tag(form_field_name(:attachment_id),
+            attachment&.id,
+            id: form_field_id(:attachment_id))
+        end
+      end
+
+      private
+
+      def dialog_link
+        link_to_dialog(
+          render_icon("file-add"),
+          editable? ? alchemy.admin_attachments_path(
+            form_field_id: form_field_id(:attachment_id),
+            only: Array(settings[:only]),
+            except: Array(settings[:except])
+          ) : nil,
+          {
+            title: Alchemy.t(:assign_file),
+            size: "780x585",
+            padding: false
+          },
+          class: "file_icon",
+          title: editable? ? Alchemy.t(:assign_file) : nil
+        )
+      end
+    end
+  end
+end

data/app/components/alchemy/ingredients/headline_editor.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    class HeadlineEditor < BaseEditor
+      delegate :level, :levels, :size, :sizes, to: :ingredient
+
+      def input_field
+        tag.div(class: "input-field") do
+          concat text_field_tag(form_field_name,
+            value,
+            minlength: length_validation&.fetch(:minimum, nil),
+            maxlength: length_validation&.fetch(:maximum, nil),
+            readonly: !editable?,
+            required: presence_validation?,
+            pattern: format_validation,
+            id: form_field_id)
+
+          if settings[:anchor]
+            concat render(
+              "alchemy/ingredients/shared/anchor",
+              ingredient:
+            )
+          end
+
+          concat(
+            tag.div(class: ["input-addon", "right", has_size_select? ? "second" : nil].compact) do
+              content_tag("sl-tooltip",
+                content: ingredient.class.human_attribute_name(:level),
+                disabled: !editable?) do
+                select_tag(
+                  form_field_name(:level),
+                  options_for_select(level_options, level),
+                  class: "custom-select",
+                  disabled: !has_level_select? || !editable?
+                )
+              end
+            end
+          )
+
+          if has_size_select?
+            concat(
+              tag.div(class: "input-addon right") do
+                content_tag("sl-tooltip",
+                  content: ingredient.class.human_attribute_name(:size),
+                  disabled: !editable?) do
+                  select_tag(
+                    form_field_name(:size),
+                    options_for_select(size_options, size),
+                    class: "custom-select",
+                    disabled: !editable?
+                  )
+                end
+              end
+            )
+          end
+        end
+      end
+
+      private
+
+      def css_classes
+        super + [
+          has_level_select? ? "with-level-select" : nil,
+          has_size_select? ? "with-size-select" : nil
+        ].compact
+      end
+
+      def level_options
+        levels.map { |level| ["H#{level}", level] }
+      end
+
+      def size_options
+        sizes.map do |size|
+          case size
+          when Array
+            size
+          else
+            [".h#{size}", size]
+          end
+        end
+      end
+
+      def has_level_select? = level_options.many?
+      def has_size_select? = size_options.many?
+    end
+  end
+end

data/app/components/alchemy/ingredients/html_editor.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    class HtmlEditor < BaseEditor
+      def input_field
+        text_area_tag(form_field_name, value, id: form_field_id, readonly: !editable?)
+      end
+    end
+  end
+end

data/app/components/alchemy/ingredients/link_editor.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    class LinkEditor < BaseEditor
+      def input_field
+        tag.div(class: "input-field") do
+          concat text_field_tag(form_field_name,
+            value,
+            class: "thin_border text_with_icon readonly",
+            id: form_field_id,
+            "data-link-value": true,
+            minlength: length_validation&.fetch(:minimum, nil),
+            maxlength: length_validation&.fetch(:maximum, nil),
+            required: presence_validation?,
+            pattern: format_validation,
+            readonly: true,
+            tabindex: -1)
+          concat hidden_field_tag(form_field_name(:link_title), ingredient.link_title, "data-link-title": true, id: nil)
+          concat hidden_field_tag(form_field_name(:link_class_name), ingredient.link_class_name, "data-link-class": true, id: nil)
+          concat hidden_field_tag(form_field_name(:link_target), ingredient.link_target, "data-link-target": true, id: nil)
+          concat render("alchemy/ingredients/shared/link_tools",
+            ingredient:,
+            wrapper_class: "ingredient_link_buttons")
+        end
+      end
+    end
+  end
+end

data/app/components/alchemy/ingredients/node_editor.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    class NodeEditor < BaseEditor
+      delegate :node, :page, to: :ingredient
+
+      def input_field
+        render Alchemy::Admin::NodeSelect.new(
+          node,
+          url: alchemy.api_nodes_path(language_id: page&.language_id, include: :ancestors),
+          query_params: settings.fetch(:query_params, {})
+        ) do
+          text_field_tag form_field_name(:node_id),
+            node&.id,
+            id: form_field_id(:node_id),
+            class: "alchemy_selectbox full_width",
+            disabled: !editable?
+        end
+      end
+    end
+  end
+end

data/app/components/alchemy/ingredients/number_editor.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    class NumberEditor < BaseEditor
+      def input_field
+        tag.div(class: "input-field") do
+          concat text_field_tag(form_field_name,
+            value,
+            type: settings[:input_type] || "number",
+            required: presence_validation?,
+            step: settings[:step],
+            min: settings[:min],
+            max: settings[:max],
+            id: form_field_id,
+            readonly: !editable?,
+            oninput: (settings[:input_type] == "range") ? "this.nextElementSibling.value = this.value" : nil)
+          if settings[:input_type] == "range"
+            concat tag.output(value)
+          end
+          if settings[:unit]
+            concat tag.div(settings[:unit], class: "input-addon right")
+          end
+        end
+      end
+    end
+  end
+end

data/app/components/alchemy/ingredients/page_editor.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    class PageEditor < BaseEditor
+      delegate :page, to: :ingredient
+
+      def input_field
+        render Alchemy::Admin::PageSelect.new(page, allow_clear: true, query_params: settings[:query_params]) do
+          text_field_tag form_field_name(:page_id),
+            page&.id,
+            id: form_field_id(:page_id),
+            class: "full_width",
+            disabled: !editable?
+        end
+      end
+    end
+  end
+end