alchemy_cms 7.4.10 → 8.0.0.b

data/app/models/alchemy/picture.rb

@@ -28,33 +28,12 @@ module Alchemy
       large: "240x180"
     }.with_indifferent_access.freeze
 
-    CONVERTIBLE_FILE_FORMATS = %w[gif jpg jpeg png webp].freeze
-
-    TRANSFORMATION_OPTIONS = [
-      :crop,
-      :crop_from,
-      :crop_size,
-      :flatten,
-      :format,
-      :quality,
-      :size,
-      :upsample
-    ]
-
     include Alchemy::Logger
     include Alchemy::NameConversions
     include Alchemy::Taggable
     include Alchemy::TouchElements
-    include Calculations
-
-    has_many :picture_ingredients,
-      class_name: "Alchemy::Ingredients::Picture",
-      foreign_key: "related_object_id",
-      inverse_of: :related_object
+    include Alchemy::RelatableResource
 
-    has_many :elements, through: :picture_ingredients
-    has_many :pages, through: :elements
-    has_many :thumbs, class_name: "Alchemy::PictureThumb", dependent: :destroy
     has_many :descriptions, class_name: "Alchemy::PictureDescription", dependent: :destroy
 
     accepts_nested_attributes_for :descriptions, allow_destroy: true, reject_if: ->(attr) { attr[:text].blank? }
@@ -72,7 +51,7 @@ module Alchemy
 
     # Image preprocessing class
     def self.preprocessor_class
-      @_preprocessor_class ||= Preprocessor
+      @_preprocessor_class ||= Alchemy.storage_adapter.preprocessor_class
     end
 
     # Set a image preprocessing class
@@ -84,56 +63,40 @@ module Alchemy
       @_preprocessor_class = klass
     end
 
-    # Enables Dragonfly image processing
-    dragonfly_accessor :image_file, app: :alchemy_pictures do
-      # Preprocess after uploading the picture
-      after_assign do |image|
-        if has_convertible_format?
-          self.class.preprocessor_class.new(image).call
-        end
-      end
-    end
-
-    before_save :sanitize_image_file_name
-    # Create important thumbnails upfront
-    after_create -> { PictureThumb.generate_thumbs!(self) if has_convertible_format? }
+    include Alchemy.storage_adapter.picture_class_methods
 
     # We need to define this method here to have it available in the validations below.
     class << self
       def allowed_filetypes
-        Config.get(:uploader).fetch("allowed_filetypes", {}).fetch("alchemy/pictures", [])
+        Alchemy.config.uploader.allowed_filetypes.alchemy_pictures
       end
     end
 
     validates_presence_of :image_file
-    validates_size_of :image_file, maximum: Config.get(:uploader)["file_size_limit"].megabytes
-    validates_property :format,
-      of: :image_file,
-      in: allowed_filetypes,
-      case_sensitive: false,
-      message: Alchemy.t("not a valid image")
+    validates_size_of :image_file, maximum: Alchemy.config.uploader.file_size_limit.megabytes
+    validate :image_file_type_allowed, if: -> { image_file.present? }
 
-    stampable stamper_class_name: Alchemy.user_class.name
+    stampable stamper_class_name: Alchemy.user_class_name
 
     scope :named, ->(name) { where("#{table_name}.name LIKE ?", "%#{name}%") }
     scope :recent, -> { where("#{table_name}.created_at > ?", Time.current - 24.hours).order(:created_at) }
-    scope :deletable, -> do
-      where(
-        "#{table_name}.id NOT IN (SELECT related_object_id FROM alchemy_ingredients WHERE related_object_id IS NOT NULL AND related_object_type = ?)",
-        name
-      )
-    end
     scope :without_tag, -> { left_outer_joins(:taggings).where(gutentag_taggings: {id: nil}) }
-    scope :by_file_format, ->(format) { where(image_file_format: format) }
+    scope :by_file_format, ->(file_format) do
+      Alchemy.storage_adapter.by_file_format_scope(file_format)
+    end
+
+    # Case insensitive Ransack searching and sorting for name attribute
+    ransacker :name, type: :string do
+      arel_table[:name].lower
+    end
 
     # Class methods
 
     class << self
       # The class used to generate URLs for pictures
       #
-      # @see Alchemy::Picture::Url
       def url_class
-        @_url_class ||= Alchemy::Picture::Url
+        @_url_class ||= Alchemy.storage_adapter.picture_url_class
       end
 
       # Set a different picture url class
@@ -143,22 +106,16 @@ module Alchemy
         @_url_class = klass
       end
 
-      def alchemy_resource_filters
-        @_file_formats ||= distinct.pluck(:image_file_format).compact.presence || []
-        [
-          {
-            name: :by_file_format,
-            values: @_file_formats
-          },
-          {
-            name: :misc,
-            values: %w[recent last_upload without_tag deletable]
-          }
-        ]
+      def searchable_alchemy_resource_attributes
+        Alchemy.storage_adapter.searchable_alchemy_resource_attributes(name)
       end
 
-      def searchable_alchemy_resource_attributes
-        %w[name image_file_name]
+      def ransackable_attributes(_auth_object = nil)
+        Alchemy.storage_adapter.ransackable_attributes(name)
+      end
+
+      def ransackable_associations(_auth_object = nil)
+        Alchemy.storage_adapter.ransackable_associations(name)
       end
 
       def last_upload
@@ -167,33 +124,30 @@ module Alchemy
 
         Picture.where(upload_hash: last_picture.upload_hash)
       end
+
+      def ransackable_scopes(_auth_object = nil)
+        [:by_file_format, :recent, :last_upload, :without_tag, :deletable]
+      end
+
+      def file_formats(scope = all)
+        Alchemy.storage_adapter.file_formats(name, scope:)
+      end
     end
 
     # Instance methods
 
     # Returns an url (or relative path) to a processed image for use inside an image_tag helper.
     #
-    # Any additional options are passed to the url method, so you can add params to your url.
-    #
     # Example:
     #
     #   <%= image_tag picture.url(size: '320x200', format: 'png') %>
     #
-    # @see Alchemy::PictureVariant#call for transformation options
-    # @see Alchemy::Picture::Url#call for url options
     # @return [String|Nil]
     def url(options = {})
       return unless image_file
 
-      variant = PictureVariant.new(self, options.slice(*TRANSFORMATION_OPTIONS))
-      self.class.url_class.new(variant).call(
-        options.except(*TRANSFORMATION_OPTIONS).merge(
-          basename: name,
-          ext: variant.render_format,
-          name: name
-        )
-      )
-    rescue ::Dragonfly::Job::Fetch::NotFound => e
+      self.class.url_class.new(self).call(options)
+    rescue Alchemy.storage_adapter.rescuable_errors => e
       log_warning(e.message)
       nil
     end
@@ -208,7 +162,7 @@ module Alchemy
 
       url(
         flatten: true,
-        format: image_file_format || "jpg",
+        format: image_file_extension || "jpg",
         size: size
       )
     end
@@ -242,18 +196,12 @@ module Alchemy
       end
     end
 
-    # Returns the suffix of the filename.
-    #
-    def suffix
-      image_file.ext
-    end
-
     # Returns a humanized, readable name from image filename.
     #
     def humanized_name
       return "" if image_file_name.blank?
 
-      convert_to_humanized_name(image_file_name, suffix)
+      convert_to_humanized_name(image_file_name, image_file_extension)
     end
 
     # Returns the format the image should be rendered with
@@ -263,9 +211,9 @@ module Alchemy
     #
     def default_render_format
       if convertible?
-        Config.get(:image_output_format)
+        Alchemy.config.image_output_format
       else
-        image_file_format
+        image_file_extension
       end
     end
 
@@ -275,15 +223,15 @@ module Alchemy
     # image has not a convertible file format (i.e. SVG) this returns +false+
     #
     def convertible?
-      Config.get(:image_output_format) &&
-        Config.get(:image_output_format) != "original" &&
+      Alchemy.config.image_output_format &&
+        Alchemy.config.image_output_format != "original" &&
         has_convertible_format?
     end
 
     # Returns true if the image can be converted into other formats
     #
     def has_convertible_format?
-      image_file_format.in?(CONVERTIBLE_FILE_FORMATS)
+      Alchemy.storage_adapter.has_convertible_format?(self)
     end
 
     # Checks if the picture is restricted.
@@ -298,12 +246,32 @@ module Alchemy
       pages.any? && pages.not_restricted.blank?
     end
 
-    # Returns true if picture is not assigned to any Picture ingredient.
-    #
-    def deletable?
-      picture_ingredients.empty?
+    def image_file_name
+      Alchemy.storage_adapter.image_file_name(self)
+    end
+
+    def image_file_format
+      Alchemy.storage_adapter.image_file_format(self)
+    end
+
+    def image_file_size
+      Alchemy.storage_adapter.image_file_size(self)
+    end
+
+    def image_file_width
+      Alchemy.storage_adapter.image_file_width(self)
+    end
+
+    def image_file_height
+      Alchemy.storage_adapter.image_file_height(self)
     end
 
+    def image_file_extension
+      Alchemy.storage_adapter.image_file_extension(self)
+    end
+    alias_method :suffix, :image_file_extension
+    deprecate suffix: :image_file_extension, deprecator: Alchemy::Deprecation
+
     # A size String from original image file values.
     #
     # == Example
@@ -314,8 +282,12 @@ module Alchemy
       "#{image_file_width}x#{image_file_height}"
     end
 
-    def sanitize_image_file_name
-      self.image_file_name = sanitized_filename(image_file_name)
+    private
+
+    def image_file_type_allowed
+      unless image_file_extension&.in?(self.class.allowed_filetypes)
+        errors.add(:image_file, Alchemy.t("not a valid image"))
+      end
     end
   end
 end

data/app/models/alchemy/picture_variant.rb

@@ -11,7 +11,6 @@ module Alchemy
     extend Forwardable
 
     include Alchemy::Logger
-    include Alchemy::Picture::Transformations
 
     ANIMATED_IMAGE_FORMATS = %w[gif webp]
     TRANSPARENT_IMAGE_FORMATS = %w[gif webp png]
@@ -89,20 +88,20 @@ module Alchemy
       end
 
       options = {
-        flatten: !render_format.in?(ANIMATED_IMAGE_FORMATS) && picture.image_file_format == "gif"
+        flatten: !render_format.in?(ANIMATED_IMAGE_FORMATS) && picture.image_file_extension == "gif"
       }.with_indifferent_access.merge(options)
 
       encoding_options = []
 
-      convert_format = render_format.sub("jpeg", "jpg") != picture.image_file_format.sub("jpeg", "jpg")
+      convert_format = render_format.sub("jpeg", "jpg") != picture.image_file_extension.sub("jpeg", "jpg")
 
       if encodable_image? && (convert_format || options[:quality])
-        quality = options[:quality] || Config.get(:output_image_quality)
+        quality = options[:quality] || Alchemy.config.output_image_quality
         encoding_options << "-quality #{quality}"
       end
 
       if options[:flatten]
-        if render_format.in?(TRANSPARENT_IMAGE_FORMATS) && picture.image_file_format.in?(TRANSPARENT_IMAGE_FORMATS)
+        if render_format.in?(TRANSPARENT_IMAGE_FORMATS) && picture.image_file_extension.in?(TRANSPARENT_IMAGE_FORMATS)
           encoding_options << "-background transparent"
         end
         encoding_options << "-flatten"
@@ -120,5 +119,116 @@ module Alchemy
     def encodable_image?
       render_format.in?(ENCODABLE_IMAGE_FORMATS)
     end
+
+    # Returns the rendered cropped image. Tries to use the crop_from and crop_size
+    # parameters. When they can't be parsed, it just crops from the center.
+    #
+    def crop(size, crop_from = nil, crop_size = nil, upsample = false)
+      raise "No size given!" if size.empty?
+
+      render_to = inferred_sizes_from_string(size)
+      if crop_from && crop_size
+        top_left = point_from_string(crop_from)
+        crop_dimensions = inferred_sizes_from_string(crop_size)
+        xy_crop_resize(render_to, top_left, crop_dimensions, upsample)
+      else
+        center_crop(render_to, upsample)
+      end
+    end
+
+    # Returns the rendered resized image using imagemagick directly.
+    #
+    def resize(size, upsample = false)
+      image_file.thumbnail(upsample ? size : "#{size}>")
+    end
+
+    # Given a string with an x, this function return a Hash with key :x and :y
+    #
+    def point_from_string(string = "0x0")
+      string = "0x0" if string.empty?
+      raise ArgumentError if !string.match(/(\d*x)|(x\d*)/)
+
+      x, y = string.scan(/(\d*)x(\d*)/)[0].map(&:to_i)
+
+      x = 0 if x.nil?
+      y = 0 if y.nil?
+      {
+        x: x,
+        y: y
+      }
+    end
+
+    def inferred_sizes_from_string(string)
+      sizes = sizes_from_string(string)
+      ratio = image_file_width.to_f / image_file_height
+
+      if sizes[:width].zero?
+        sizes[:width] = (sizes[:height] * ratio).round.to_i
+      end
+      if sizes[:height].zero?
+        sizes[:height] = (sizes[:width] / ratio).round.to_i
+      end
+
+      sizes
+    end
+
+    # Given a string with an x, this function returns a Hash with point
+    # :width and :height.
+    #
+    def sizes_from_string(string)
+      width, height = string.to_s.split("x", 2).map(&:to_i)
+
+      {
+        width: width,
+        height: height
+      }
+    end
+
+    # Returns true if both dimensions of the base image are bigger than the dimensions hash.
+    #
+    def is_bigger_than?(dimensions)
+      image_file_width > dimensions[:width] && image_file_height > dimensions[:height]
+    end
+
+    # Returns true is one dimension of the base image is smaller than the dimensions hash.
+    #
+    def is_smaller_than?(dimensions)
+      !is_bigger_than?(dimensions)
+    end
+
+    # Converts a dimensions hash to a string of from "20x20"
+    #
+    def dimensions_to_string(dimensions)
+      "#{dimensions[:width]}x#{dimensions[:height]}"
+    end
+
+    # Uses imagemagick to make a centercropped thumbnail. Does not scale the image up.
+    #
+    def center_crop(dimensions, upsample)
+      if is_smaller_than?(dimensions) && upsample == false
+        dimensions = reduce_to_image(dimensions)
+      end
+      image_file.thumbnail("#{dimensions_to_string(dimensions)}#")
+    end
+
+    # Use imagemagick to custom crop an image. Uses -thumbnail for better performance when resizing.
+    #
+    def xy_crop_resize(dimensions, top_left, crop_dimensions, upsample)
+      crop_argument = dimensions_to_string(crop_dimensions)
+      crop_argument += "+#{top_left[:x]}+#{top_left[:y]}"
+
+      resize_argument = dimensions_to_string(dimensions)
+      resize_argument += ">" unless upsample
+      image_file.crop_resize(crop_argument, resize_argument)
+    end
+
+    # Used when centercropping.
+    #
+    def reduce_to_image(dimensions)
+      {
+        width: [dimensions[:width].to_i, image_file_width.to_i].min,
+        height: [dimensions[:height].to_i, image_file_height.to_i].min
+      }
+    end
   end
 end

data/{lib → app/models}/alchemy/resource.rb

@@ -98,8 +98,10 @@ module Alchemy
   #     resource = Resource.new('/admin/tags', {"engine_name"=>"alchemy"}, Gutentag::Tag)
   #
   class Resource
+    include Alchemy::Admin::ResourceName
+
     attr_accessor :resource_relations, :model_associations
-    attr_reader :model
+    attr_reader :model, :controller_path
 
     DEFAULT_SKIPPED_ATTRIBUTES = %w[id created_at creator_id]
     DEFAULT_SKIPPED_ASSOCIATIONS = %w[creator]
@@ -119,18 +121,6 @@ module Alchemy
       end
     end
 
-    def resource_array
-      @_resource_array ||= controller_path_array.reject { |el| el == "admin" }
-    end
-
-    def resources_name
-      @_resources_name ||= resource_array.last
-    end
-
-    def resource_name
-      @_resource_name ||= resources_name.singularize
-    end
-
     def namespaced_resource_name
       @_namespaced_resource_name ||= begin
         namespaced_resources_name.to_s.singularize
@@ -296,11 +286,7 @@ module Alchemy
     end
 
     def guess_model_from_controller_path
-      resource_array.join("/").classify.constantize
-    end
-
-    def controller_path_array
-      @controller_path.split("/")
+      resource_model_name.classify.constantize
     end
 
     def namespace_diff

data/{lib → app/models}/alchemy/searchable_resource.rb

@@ -21,6 +21,21 @@ module Alchemy
       searchable_alchemy_resource_associations
     end
 
+    # Allow all scopes used in resource filters to be used with Ransack
+    def ransackable_scopes(_auth_object = nil)
+      if respond_to?(:alchemy_resource_filters)
+        alchemy_resource_filters.flat_map do |filter_set|
+          if respond_to?(filter_set[:name])
+            filter_set[:name].to_s
+          else
+            filter_set[:values].map(&:to_s)
+          end
+        end
+      else
+        []
+      end
+    end
+
     protected
 
     def searchable_alchemy_resource_attributes

data/app/models/alchemy/site/layout.rb

@@ -42,8 +42,8 @@ module Alchemy
     #
     def page_layout_names(layoutpages: false)
       page_layout_definitions.select do |layout|
-        !!layout["layoutpage"] && layoutpages || !layout["layoutpage"] && !layoutpages
-      end.collect { |layout| layout["name"] }
+        !!layout.layoutpage && layoutpages || !layout.layoutpage && !layoutpages
+      end.tap { _1.collect!(&:name) }
     end
 
     # Returns sites page layout definitions
@@ -52,11 +52,11 @@ module Alchemy
     #
     def page_layout_definitions
       if definition["page_layouts"].presence
-        Alchemy::PageLayout.all.select do |layout|
-          layout["name"].in?(definition["page_layouts"])
+        Alchemy::PageDefinition.all.select do |layout|
+          layout.name.in?(definition["page_layouts"])
         end
       else
-        Alchemy::PageLayout.all
+        Alchemy::PageDefinition.all
       end
     end
 

data/app/models/alchemy/site.rb

@@ -21,12 +21,7 @@ module Alchemy
     validates_uniqueness_of :host, case_sensitive: false
 
     # associations
-    has_many :languages
-
-    before_destroy if: -> { languages.any? } do
-      errors.add(:languages, :still_present)
-      throw(:abort)
-    end
+    has_many :languages, dependent: :restrict_with_error
 
     scope :published, -> { where(public: true) }
 
@@ -57,21 +52,6 @@ module Alchemy
     end
 
     class << self
-      # @deprecated Use {Alchemy::Current#site=} instead.
-      def current=(site)
-        Current.site = site
-      end
-      deprecate "current=": :"Alchemy::Current.site=", deprecator: Alchemy::Deprecation
-
-      # @deprecated Use {Alchemy::Current#site} instead.
-      def current
-        Current.site
-      end
-      deprecate current: :"Alchemy::Current.site", deprecator: Alchemy::Deprecation
-
-      alias_method :default, :first
-      deprecate default: :first, deprecator: Alchemy::Deprecation
-
       def find_for_host(host)
         # These are split up into two separate queries in order to run the
         # fastest query first (selecting the domain by its primary host name).

data/app/models/alchemy/storage_adapter/active_storage/attachment_url.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class StorageAdapter
+    # The class representing an URL to an ActiveStorage attachment
+    #
+    class ActiveStorage::AttachmentUrl
+      attr_reader :attachment
+
+      def initialize(attachment)
+        @attachment = attachment
+      end
+
+      # The attachment url
+      #
+      # @param [Hash] options
+      # @option options [Symbol] :download return a URL for downloading the attachment
+      # @option options [Symbol] :name The filename
+      # @option options [Symbol] :format The file extension
+      #
+      # @return [String]
+      #
+      def call(options = {})
+        if attachment.file.attached?
+          options[:format] ||= attachment.suffix
+          if options.delete(:download)
+            routes.download_attachment_path(attachment, options)
+          else
+            routes.show_attachment_path(attachment, options)
+          end
+        end
+      end
+
+      private
+
+      def routes
+        Alchemy::Engine.routes.url_helpers
+      end
+    end
+  end
+end

data/app/models/alchemy/storage_adapter/active_storage/picture_url.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class StorageAdapter
+    # Returns the URL to a variant of a picture using ActiveStorage
+    class ActiveStorage::PictureUrl
+      attr_reader :picture, :image_file
+
+      # @param [Alchemy::Picture]
+      #
+      def initialize(picture)
+        @picture = picture
+        @image_file = picture.image_file
+      end
+
+      # The URL to a variant of a picture
+      #
+      # @return [String]
+      #
+      def call(options = {})
+        variant_options = DragonflyToImageProcessing.call(options)
+        variant_options[:format] = options[:format] || default_output_format
+        variant = image_file&.variant(variant_options)
+        return unless variant
+
+        Rails.application.routes.url_helpers.rails_blob_path(
+          variant,
+          {
+            filename: filename(options),
+            format: variant_options[:format],
+            only_path: true
+          }
+        )
+      end
+
+      private
+
+      def filename(options = {})
+        if picture.name.presence
+          picture.name.to_param
+        else
+          picture.image_file_name
+        end
+      end
+
+      def default_output_format
+        if Alchemy.config.image_output_format == "original"
+          picture.image_file_extension
+        else
+          Alchemy.config.image_output_format
+        end
+      end
+    end
+  end
+end