alchemy_cms 5.2.4 → 6.0.0.b1

data/app/models/alchemy/essence_picture.rb

@@ -23,6 +23,8 @@
 
 module Alchemy
   class EssencePicture < BaseRecord
+    include Alchemy::PictureThumbnails
+
     acts_as_essence ingredient_column: :picture, belongs_to: {
       class_name: "Alchemy::Picture",
       foreign_key: :picture_id,
@@ -30,81 +32,9 @@ module Alchemy
       optional: true,
     }
 
-    delegate :image_file_width, :image_file_height, :image_file, to: :picture
-    before_save :fix_crop_values
-    before_save :replace_newlines
-
-    include Alchemy::Picture::Transformations
-
-    # The url to show the picture.
-    #
-    # Takes all values like +name+ and crop sizes (+crop_from+, +crop_size+ from the build in graphical image cropper)
-    # and also adds the security token.
-    #
-    # You typically want to set the size the picture should be resized to.
-    #
-    # === Example:
-    #
-    #   essence_picture.picture_url(size: '200x300', crop: true, format: 'gif')
-    #   # '/pictures/1/show/200x300/crop/cats.gif?sh=765rfghj'
-    #
-    # @option options size [String]
-    #   The size the picture should be resized to.
-    #
-    # @option options format [String]
-    #   The format the picture should be rendered in.
-    #   Defaults to the +image_output_format+ from the +Alchemy::Config+.
-    #
-    # @option options crop [Boolean]
-    #   If set to true the picture will be cropped to fit the size value.
-    #
-    # @return [String]
-    def picture_url(options = {})
-      return if picture.nil?
-
-      picture.url(picture_url_options.merge(options)) || "missing-image.png"
-    end
+    delegate :settings, to: :content
 
-    # Picture rendering options
-    #
-    # Returns the +default_render_format+ of the associated +Alchemy::Picture+
-    # together with the +crop_from+ and +crop_size+ values
-    #
-    # @return [HashWithIndifferentAccess]
-    def picture_url_options
-      return {} if picture.nil?
-
-      {
-        format: picture.default_render_format,
-        crop_from: crop_from.presence,
-        crop_size: crop_size.presence,
-        size: content.settings[:size],
-      }.with_indifferent_access
-    end
-
-    # Returns an url for the thumbnail representation of the assigned picture
-    #
-    # It takes cropping values into account, so it always represents the current
-    # image displayed in the frontend.
-    #
-    # @return [String]
-    def thumbnail_url
-      return if picture.nil?
-
-      crop = crop_values_present? || content.settings[:crop]
-      size = render_size || content.settings[:size]
-
-      options = {
-        size: thumbnail_size(size, crop),
-        crop: !!crop,
-        crop_from: crop_from.presence,
-        crop_size: crop_size.presence,
-        flatten: true,
-        format: picture.image_file_format,
-      }
-
-      picture.url(options) || "alchemy/missing-image.svg"
-    end
+    before_save :replace_newlines
 
     # The name of the picture used as preview text in element editor views.
     #
@@ -118,18 +48,6 @@ module Alchemy
       picture.name.to_s[0..max - 1]
     end
 
-    # A Hash of coordinates suitable for the graphical image cropper.
-    #
-    # @return [Hash]
-    def cropping_mask
-      return if crop_from.blank? || crop_size.blank?
-
-      crop_from = point_from_string(read_attribute(:crop_from))
-      crop_size = sizes_from_string(read_attribute(:crop_size))
-
-      point_and_mask_to_points(crop_from, crop_size)
-    end
-
     # Returns a serialized ingredient value for json api
     #
     # @return [String]
@@ -137,38 +55,8 @@ module Alchemy
       picture_url(content.settings)
     end
 
-    # Show image cropping link for content
-    def allow_image_cropping?
-      content && content.settings[:crop] && picture &&
-        picture.can_be_cropped_to?(
-          content.settings[:size],
-          content.settings[:upsample],
-        ) && !!picture.image_file
-    end
-
-    def crop_values_present?
-      crop_from.present? && crop_size.present?
-    end
-
     private
 
-    def fix_crop_values
-      %i(crop_from crop_size).each do |crop_value|
-        if self[crop_value].is_a?(String)
-          write_attribute crop_value, normalize_crop_value(crop_value)
-        end
-      end
-    end
-
-    def normalize_crop_value(crop_value)
-      self[crop_value].split("x").map { |n| normalize_number(n) }.join("x")
-    end
-
-    def normalize_number(number)
-      number = number.to_f.round
-      number.negative? ? 0 : number
-    end
-
     def replace_newlines
       return nil if caption.nil?
 

data/app/models/alchemy/essence_richtext.rb

@@ -17,6 +17,7 @@ module Alchemy
     acts_as_essence preview_text_column: "stripped_body"
 
     before_save :strip_content
+    before_save :sanitize_content
 
     def has_tinymce?
       true
@@ -27,5 +28,16 @@ module Alchemy
     def strip_content
       self.stripped_body = Rails::Html::FullSanitizer.new.sanitize(body)
     end
+
+    def sanitize_content
+      self.sanitized_body = Rails::Html::SafeListSanitizer.new.sanitize(
+        body,
+        content_sanitizer_settings
+      )
+    end
+
+    def content_sanitizer_settings
+      content&.settings&.fetch(:sanitizer, {}) || {}
+    end
   end
 end

data/app/models/alchemy/essence_video.rb

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

data/app/models/alchemy/image_cropper_settings.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module Alchemy
+  # Settings for the graphical JS image cropper
+  class ImageCropperSettings
+    attr_reader :render_size, :default_crop_from, :default_crop_size, :fixed_ratio, :image_width, :image_height
+
+    def initialize(render_size:, default_crop_from:, default_crop_size:, fixed_ratio:, image_width:, image_height:)
+      @render_size = render_size || [0, 0]
+      @fixed_ratio = fixed_ratio
+      @image_width = image_width.to_i
+      @image_height = image_height.to_i
+      @default_crop_from = default_crop_from || [0, 0]
+      @default_crop_size = default_crop_size || [@image_width, @image_height]
+    end
+
+    def to_h
+      return {} if image_width.zero? || image_height.zero?
+
+      {
+        min_size: large_enough? ? min_size : false,
+        ratio: ratio,
+        default_box: default_box,
+        image_size: [image_width, image_height],
+      }.freeze
+    end
+
+    def [](key)
+      to_h[key]
+    end
+
+    private
+
+    def ratio
+      return false if fixed_ratio == false
+      return ratio_from_size if fixed_ratio.nil?
+
+      Float(fixed_ratio)
+    end
+
+    # Only returns an array of width and height if image is large enough
+    # or false to disable min size option of the image cropper
+    def large_enough?
+      return true if render_size.any?(&:zero?)
+
+      image_width >= render_size[0] && image_height >= render_size[1]
+    end
+
+    # Infers the aspect ratio from size or fixed_ratio. If you don't want a fixed
+    # aspect ratio, don't specify a size or only width or height.
+    #
+    def ratio_from_size
+      if render_size.none?(&:zero?)
+        render_size[0].to_f / render_size[1]
+      elsif [image_width, image_height].none?(&:zero?)
+        image_width.to_f / image_height
+      else
+        false
+      end
+    end
+
+    # Infers the minimum width or height
+    # if the aspect ratio and one dimension is specified.
+    #
+    def min_size
+      return render_size unless ratio
+
+      if render_size[1].zero?
+        [render_size[0], (render_size[0] / ratio).to_i]
+      else
+        [(render_size[1] * ratio).to_i, render_size[1]]
+      end
+    end
+
+    # Given a point and a mask, this function returns the area on the
+    # underlying canvas as a Hash of two points
+    #
+    def default_box
+      [
+        default_crop_from[0],
+        default_crop_from[1],
+        default_crop_from[0] + default_crop_size[0],
+        default_crop_from[1] + default_crop_size[1],
+      ]
+    end
+  end
+end

data/app/models/alchemy/ingredient.rb

@@ -0,0 +1,219 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class Ingredient < BaseRecord
+    class DefinitionError < StandardError; end
+
+    include Hints
+
+    self.abstract_class = true
+    self.table_name = "alchemy_ingredients"
+
+    belongs_to :element, touch: true, class_name: "Alchemy::Element", inverse_of: :ingredients
+    belongs_to :related_object, polymorphic: true, optional: true
+
+    validates :type, presence: true
+    validates :role, presence: true
+
+    validates_with Alchemy::IngredientValidator, on: :update, if: :has_validations?
+
+    scope :audios, -> { where(type: "Alchemy::Ingredients::Audio") }
+    scope :booleans, -> { where(type: "Alchemy::Ingredients::Boolean") }
+    scope :datetimes, -> { where(type: "Alchemy::Ingredients::Datetime") }
+    scope :files, -> { where(type: "Alchemy::Ingredients::File") }
+    scope :headlines, -> { where(type: "Alchemy::Ingredients::Headline") }
+    scope :htmls, -> { where(type: "Alchemy::Ingredients::Html") }
+    scope :links, -> { where(type: "Alchemy::Ingredients::Link") }
+    scope :nodes, -> { where(type: "Alchemy::Ingredients::Node") }
+    scope :pages, -> { where(type: "Alchemy::Ingredients::Page") }
+    scope :pictures, -> { where(type: "Alchemy::Ingredients::Picture") }
+    scope :richtexts, -> { where(type: "Alchemy::Ingredients::Richtext") }
+    scope :selects, -> { where(type: "Alchemy::Ingredients::Select") }
+    scope :texts, -> { where(type: "Alchemy::Ingredients::Text") }
+    scope :videos, -> { where(type: "Alchemy::Ingredients::Video") }
+
+    class << self
+      # Builds concrete ingredient class as described in the +elements.yml+
+      def build(attributes = {})
+        element = attributes[:element]
+        raise ArgumentError, "No element given. Please pass element in attributes." if element.nil?
+        raise ArgumentError, "No role given. Please pass role in attributes." if attributes[:role].nil?
+
+        definition = element.ingredient_definition_for(attributes[:role])
+        if definition.nil?
+          raise DefinitionError,
+            "No definition found for #{attributes[:role]}. Please define #{attributes[:role]} on #{element[:name]}."
+        end
+
+        ingredient_class = Ingredient.ingredient_class_by_type(definition[:type])
+        ingredient_class.new(
+          type: Ingredient.normalize_type(definition[:type]),
+          value: default_value(definition),
+          role: definition[:role],
+          element: element,
+        )
+      end
+
+      # Creates concrete ingredient class as described in the +elements.yml+
+      def create(attributes = {})
+        build(attributes).tap(&:save)
+      end
+
+      # Defines getter and setter method aliases for related object
+      #
+      # @param [String|Symbol] The name of the alias
+      # @param [String] The class name of the related object
+      def related_object_alias(name, class_name:)
+        alias_method name, :related_object
+        alias_method "#{name}=", :related_object=
+
+        # Somehow Rails STI does not allow us to use `alias_method` for the related_object_id
+        define_method "#{name}_id" do
+          related_object_id
+        end
+
+        define_method "#{name}_id=" do |id|
+          self.related_object_id = id
+          self.related_object_type = class_name
+        end
+      end
+
+      # Returns an ingredient class by type
+      #
+      # Raises ArgumentError if there is no such class in the
+      # +Alchemy::Ingredients+ module namespace.
+      #
+      # If you add custom ingredient class,
+      # put them in the +Alchemy::Ingredients+ module namespace
+      #
+      # @param [String] The ingredient class name to constantize
+      # @return [Class]
+      def ingredient_class_by_type(ingredient_type)
+        Alchemy::Ingredients.const_get(ingredient_type.to_s.classify.demodulize)
+      end
+
+      # Modulize ingredient type
+      #
+      # Makes sure the passed ingredient type is in the +Alchemy::Ingredients+
+      # module namespace.
+      #
+      # If you add custom ingredient class,
+      # put them in the +Alchemy::Ingredients+ module namespace
+      # @param [String] Ingredient class name
+      # @return [String]
+      def normalize_type(ingredient_type)
+        "Alchemy::Ingredients::#{ingredient_type.to_s.classify.demodulize}"
+      end
+
+      def translated_label_for(role, element_name = nil)
+        Alchemy.t(
+          role,
+          scope: "ingredient_roles.#{element_name}",
+          default: Alchemy.t("ingredient_roles.#{role}", default: role.humanize),
+        )
+      end
+
+      private
+
+      # Returns the default value from ingredient definition
+      #
+      # If the value is a symbol it gets passed through i18n
+      # inside the +alchemy.default_ingredient_texts+ scope
+      def default_value(definition)
+        default = definition[:default]
+        case default
+        when Symbol
+          Alchemy.t(default, scope: :default_ingredient_texts)
+        else
+          default
+        end
+      end
+    end
+
+    # Compatibility method for access from element
+    def essence
+      self
+    end
+
+    # The value or the related object if present
+    def value
+      related_object || self[:value]
+    end
+
+    # Settings for this ingredient from the +elements.yml+ definition.
+    def settings
+      definition[:settings] || {}
+    end
+
+    # Fetches value from settings
+    #
+    # @param key [Symbol]               - The hash key you want to fetch the value from
+    # @param options [Hash]             - An optional Hash that can override the settings.
+    #                                     Normally passed as options hash into the content
+    #                                     editor view.
+    def settings_value(key, options = {})
+      settings.merge(options || {})[key.to_sym]
+    end
+
+    # Definition hash for this ingredient from +elements.yml+ file.
+    #
+    def definition
+      return {} unless element
+
+      element.ingredient_definition_for(role) || {}
+    end
+
+    # The first 30 characters of the value
+    #
+    # Used by the Element#preview_text method.
+    #
+    # @param [Integer] max_length (30)
+    #
+    def preview_text(maxlength = 30)
+      value.to_s[0..maxlength - 1]
+    end
+
+    # Cross DB adapter data accessor that works
+    def data
+      @_data ||= (self[:data] || {}).with_indifferent_access
+    end
+
+    # The path to the view partial of the ingredient
+    # @return [String]
+    def to_partial_path
+      "alchemy/ingredients/#{partial_name}_view"
+    end
+
+    # The demodulized underscored class name of the ingredient
+    # @return [String]
+    def partial_name
+      self.class.name.demodulize.underscore
+    end
+
+    # @return [Boolean]
+    def has_validations?
+      !!definition[:validate]
+    end
+
+    # @return [Boolean]
+    def has_hint?
+      !!definition[:hint]
+    end
+
+    # @return [Boolean]
+    def deprecated?
+      !!definition[:deprecated]
+    end
+
+    # @return [Boolean]
+    def has_tinymce?
+      false
+    end
+
+    private
+
+    def hint_translation_attribute
+      role
+    end
+  end
+end

data/app/models/alchemy/ingredient_validator.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Alchemy
+  # Ingredient Validations:
+  #
+  # Ingredient validations can be set inside the +config/elements.yml+ file.
+  #
+  # Supported validations are:
+  #
+  # * presence
+  # * uniqueness
+  # * format
+  #
+  # *) format needs to come with a regex or a predefined matcher string as its value.
+  #
+  # There are already predefined format matchers listed in the +config/alchemy/config.yml+ file.
+  # It is also possible to add own format matchers there.
+  #
+  # Example of format matchers in +config/alchemy/config.yml+:
+  #
+  # format_matchers:
+  #   email: !ruby/regexp '/\A[^@\s]+@([^@\s]+\.)+[^@\s]+\z/'
+  #   url:   !ruby/regexp '/\A[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?\z/ix'
+  #   ssl:   !ruby/regexp '/https:\/\/[\S]+/'
+  #
+  # Example of an element definition with ingredient validations:
+  #
+  #   - name: person
+  #     ingredients:
+  #     - role: name
+  #       type: Text
+  #       validate: [presence]
+  #     - role: email
+  #       type: Text
+  #       validate: [format: 'email']
+  #     - role: homepage
+  #       type: Text
+  #       validate: [format: !ruby/regexp '^[a-z0-9]+([\-\.]{1}[a-z0-9]+)*\.[a-z]{2,5}(:[0-9]{1,5})?(\/.*)?$']
+  #
+  # Example of an element definition with chained validations.
+  #
+  #   - name: person
+  #     ingredients:
+  #     - role: name
+  #       type: Text
+  #       validate: [presence, uniqueness, format: 'name']
+  #
+  class IngredientValidator < ActiveModel::Validator
+    def validate(ingredient)
+      @ingredient = ingredient
+      validations.each do |validation|
+        if validation.respond_to?(:keys)
+          validation.map do |key, value|
+            send("validate_#{key}", value)
+          end
+        else
+          send("validate_#{validation}")
+        end
+      end
+    end
+
+    private
+
+    attr_reader :ingredient
+
+    def validations
+      ingredient.definition.fetch(:validate, [])
+    end
+
+    def validate_presence(*)
+      if ingredient.value.blank?
+        ingredient.errors.add(:value, :blank)
+      end
+    end
+
+    def validate_uniqueness(*)
+      if duplicates.any?
+        ingredient.errors.add(:value, :taken)
+      end
+    end
+
+    def validate_format(format)
+      matcher = Alchemy::Config.get("format_matchers")[format] || format
+      if !ingredient.value.to_s.match?(Regexp.new(matcher))
+        ingredient.errors.add(:value, :invalid)
+      end
+    end
+
+    def duplicates
+      ingredient.class
+        .joins(:element).merge(Alchemy::Element.available)
+        .where(Alchemy::Element.table_name => { name: ingredient.element.name })
+        .where(value: ingredient.value)
+        .where.not(id: ingredient.id)
+    end
+  end
+end

data/app/models/alchemy/ingredients/audio.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    # A audio attachment
+    #
+    class Audio < Alchemy::Ingredient
+      store_accessor :data,
+        :autoplay,
+        :controls,
+        :muted,
+        :loop
+
+      related_object_alias :attachment, class_name: "Alchemy::Attachment"
+
+      delegate :name, to: :attachment, allow_nil: true
+
+      # The first 30 characters of the attachments name
+      #
+      # Used by the Element#preview_text method.
+      #
+      # @param [Integer] max_length (30)
+      #
+      def preview_text(max_length = 30)
+        name.to_s[0..max_length - 1]
+      end
+    end
+  end
+end

data/app/models/alchemy/ingredients/boolean.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    # A boolean value
+    #
+    class Boolean < Alchemy::Ingredient
+      def value
+        ActiveRecord::Type::Boolean.new.cast(self[:value])
+      end
+
+      # The localized value
+      #
+      # Used by the Element#preview_text method.
+      #
+      def preview_text(_max_length = nil)
+        Alchemy.t(value, scope: "ingredient_values.boolean")
+      end
+    end
+  end
+end

data/app/models/alchemy/ingredients/datetime.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    # A datetime value
+    #
+    class Datetime < Alchemy::Ingredient
+      def value
+        ActiveRecord::Type::DateTime.new.cast(self[:value])
+      end
+
+      # Returns localized date for the Element#preview_text method.
+      def preview_text(_maxlength = nil)
+        return "" unless value
+
+        ::I18n.l(value, format: :'alchemy.essence_date')
+      end
+    end
+  end
+end

data/app/models/alchemy/ingredients/file.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Alchemy
+  module Ingredients
+    # A link to a file
+    #
+    # Attach Alchemy::Attachment into this ingredient
+    #
+    class File < Alchemy::Ingredient
+      store_accessor :data,
+        :css_class,
+        :link_text,
+        :title
+
+      related_object_alias :attachment, class_name: "Alchemy::Attachment"
+
+      delegate :name, to: :attachment, allow_nil: true
+
+      # The first 30 characters of the attachments name
+      #
+      # Used by the Element#preview_text method.
+      #
+      # @param [Integer] max_length (30)
+      #
+      def preview_text(max_length = 30)
+        attachment&.name.to_s[0..max_length - 1]
+      end
+    end
+  end
+end