alchemy_cms 7.4.10 → 8.0.0.b

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

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class StorageAdapter
+    class ActiveStorage::Preprocessor
+      def initialize(attachable)
+        @attachable = attachable
+      end
+
+      # Preprocess images after upload
+      #
+      # Define preprocessing options in the Alchemy.config
+      #
+      #   preprocess_image_resize [String] - Downsizing example: '1000x1000>'
+      #
+      def call
+        max_image_size = Alchemy.config.get(:preprocess_image_resize)
+        if max_image_size.present?
+          self.class.process_thumb(attachable, size: max_image_size)
+        end
+      end
+
+      attr_reader :attachable
+
+      class << self
+        def generate_thumbs!(attachable)
+          Alchemy::Picture::THUMBNAIL_SIZES.values.each do |size|
+            process_thumb(attachable, size: size, flatten: true)
+          end
+        end
+
+        def process_thumb(attachable, options = {})
+          attachable.variant :thumb,
+            **Alchemy::DragonflyToImageProcessing.call(options),
+            preprocessed: true
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+module Alchemy
+  class StorageAdapter
+    module ActiveStorage
+      module PictureClassMethods
+        def self.included(base)
+          base.has_one_attached :image_file do |attachable|
+            # Only works in Rails 7.1+
+            # https://github.com/rails/rails/pull/47473
+            Alchemy.storage_adapter.preprocessor_class.new(attachable).call
+            Alchemy.storage_adapter.preprocessor_class.generate_thumbs!(attachable)
+          end
+        end
+      end
+
+      module AttachmentClassMethods
+        def self.included(base)
+          base.has_one_attached :file
+        end
+      end
+
+      extend self
+
+      def attachment_url_class
+        AttachmentUrl
+      end
+
+      def preprocessor_class
+        Preprocessor
+      end
+
+      def picture_url_class
+        PictureUrl
+      end
+
+      def file_formats(class_name, scope:)
+        attachment_scope = case class_name
+        when "Alchemy::Attachment" then scope.with_attached_file
+        when "Alchemy::Picture" then scope.with_attached_image_file
+        end
+
+        attachment_scope.pluck("active_storage_blobs.content_type").uniq.tap(&:compact!).presence || []
+      end
+
+      # @param [String]
+      # @return [Array<String>]
+      def searchable_alchemy_resource_attributes(class_name)
+        case class_name
+        when "Alchemy::Attachment"
+          %w[name file_blob_filename]
+        when "Alchemy::Picture"
+          %w[name image_file_blob_filename]
+        end
+      end
+
+      # @param [String]
+      # @return [Array<String>]
+      def ransackable_attributes(_class_name)
+        %w[name]
+      end
+
+      # @param [String]
+      # @return [Array<String>]
+      def ransackable_associations(class_name)
+        case class_name
+        when "Alchemy::Attachment"
+          %w[file_blob]
+        when "Alchemy::Picture"
+          %w[image_file_blob]
+        end
+      end
+
+      def rescuable_errors
+        ::ActiveStorage::Error
+      end
+
+      # @param [String]
+      # @return [Alchemy::Picture::ActiveRecord_Relation]
+      def by_file_format_scope(file_format)
+        Picture.with_attached_image_file.joins(:image_file_blob).where(active_storage_blobs: {content_type: file_format})
+      end
+
+      # @param [String]
+      # @return [Alchemy::Atachment::ActiveRecord_Relation]
+      def by_file_type_scope(file_type)
+        Attachment.with_attached_file.joins(:file_blob).where(active_storage_blobs: {content_type: file_type})
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [String]
+      def file_name(attachment)
+        attachment.file&.filename&.to_s
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [Integer]
+      def file_size(attachment)
+        attachment.file&.byte_size
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [String]
+      def file_mime_type(attachment)
+        attachment.file&.content_type
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [String]
+      def file_extension(attachment)
+        attachment.file&.filename&.extension
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [TrueClass, FalseClass]
+      def has_convertible_format?(picture)
+        picture.image_file&.variable?
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [String]
+      def image_file_name(picture)
+        picture.image_file&.filename&.to_s
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [String]
+      def image_file_format(picture)
+        picture.image_file&.content_type
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [Integer]
+      def image_file_size(picture)
+        picture.image_file&.byte_size
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [Integer]
+      def image_file_width(picture)
+        picture.image_file&.metadata&.fetch(:width, nil)
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [Integer]
+      def image_file_height(picture)
+        picture.image_file&.metadata&.fetch(:height, nil)
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [Integer]
+      def image_file_extension(picture)
+        picture.image_file&.filename&.extension&.downcase
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [TrueClass, FalseClass]
+      def image_file_present?(picture)
+        picture.image_file.attached?
+      end
+
+      # @param Alchemy::Picture::ActiveRecord_Relation
+      # @return Alchemy::Picture::ActiveRecord_Relation
+      def preloaded_pictures(pictures)
+        pictures.with_attached_image_file
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [TrueClass, FalseClass]
+      def set_attachment_name?(attachment)
+        attachment.file.changed?
+      end
+    end
+  end
+end

data/app/models/alchemy/{attachment/url.rb → storage_adapter/dragonfly/attachment_url.rb}

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
 module Alchemy
-  class Attachment < BaseRecord
-    # The class representing an URL to an attachment
+  class StorageAdapter
+    # The class representing an URL to an Dragonfly attachment
     #
-    # Set a different one
-    #
-    #     Alchemy::Attachment.url_class = MyRemoteUrlClass
-    #
-    class Url
+    class Dragonfly::AttachmentUrl
+      attr_reader :attachment
+
       def initialize(attachment)
         @attachment = attachment
       end
@@ -23,11 +21,13 @@ module Alchemy
       # @return [String]
       #
       def call(options = {})
-        options[:format] ||= @attachment.suffix
-        if options.delete(:download)
-          routes.download_attachment_path(@attachment, options)
-        else
-          routes.show_attachment_path(@attachment, options)
+        if attachment.file
+          options[:format] ||= attachment.suffix
+          if options.delete(:download)
+            routes.download_attachment_path(attachment, options)
+          else
+            routes.show_attachment_path(attachment, options)
+          end
         end
       end
 

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

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class StorageAdapter
+    class Dragonfly::PictureUrl
+      TRANSFORMATION_OPTIONS = [
+        :crop,
+        :crop_from,
+        :crop_size,
+        :flatten,
+        :format,
+        :quality,
+        :size,
+        :upsample
+      ]
+
+      attr_reader :picture, :variant, :thumb
+
+      # @param [Alchemy::Picture]
+      #
+      def initialize(picture)
+        @picture = picture
+      end
+
+      # The URL to a variant of a picture
+      #
+      # @return [String]
+      #
+      def call(variant_options = {})
+        set_variant(variant_options)
+
+        params = {
+          basename: picture.name,
+          ext: variant.render_format,
+          name: picture.name
+        }
+
+        return variant.image.url(params) unless processible_image?
+
+        "/#{uid}"
+      end
+
+      private
+
+      def set_variant(options = {})
+        @variant = PictureVariant.new(picture, options.slice(*TRANSFORMATION_OPTIONS))
+      end
+
+      def processible_image?
+        variant.image.is_a?(::Dragonfly::Job)
+      end
+
+      def uid
+        signature = PictureThumb::Signature.call(variant)
+        if find_thumb_by(signature)
+          thumb.uid
+        else
+          uid = PictureThumb::Uid.call(signature, variant)
+          ActiveRecord::Base.connected_to(role: ActiveRecord.writing_role) do
+            PictureThumb::Create.call(variant, signature, uid)
+          end
+          uid
+        end
+      end
+
+      def find_thumb_by(signature)
+        @thumb = if picture.thumbs.loaded?
+          picture.thumbs.find { |t| t.signature == signature }
+        else
+          picture.thumbs.find_by(signature: signature)
+        end
+      end
+    end
+  end
+end

data/app/models/alchemy/{picture → storage_adapter/dragonfly}/preprocessor.rb

@@ -1,20 +1,20 @@
 # frozen_string_literal: true
 
 module Alchemy
-  class Picture < BaseRecord
-    class Preprocessor
+  class StorageAdapter
+    class Dragonfly::Preprocessor
       def initialize(image_file)
         @image_file = image_file
       end
 
       # Preprocess images after upload
       #
-      # Define preprocessing options in the Alchemy::Config
+      # Define preprocessing options in the Alchemy.config
       #
       #   preprocess_image_resize [String] - Downsizing example: '1000x1000>'
       #
       def call
-        max_image_size = Alchemy::Config.get(:preprocess_image_resize)
+        max_image_size = Alchemy.config.preprocess_image_resize
         image_file.thumb!(max_image_size) if max_image_size.present?
         # Auto orient the image so EXIF orientation data is taken into account
         image_file.auto_orient!

data/app/models/alchemy/storage_adapter/dragonfly.rb

@@ -0,0 +1,205 @@
+module Alchemy
+  class StorageAdapter
+    module Dragonfly
+      module PictureClassMethods
+        def self.included(base)
+          base.class_eval do
+            dragonfly_accessor :image_file, app: :alchemy_pictures do
+              # Preprocess after uploading the picture
+              after_assign do |image|
+                if has_convertible_format?
+                  Alchemy.storage_adapter.preprocessor_class.new(image).call
+                end
+              end
+            end
+
+            has_many :thumbs, class_name: "Alchemy::PictureThumb", dependent: :destroy
+
+            before_save do
+              self.image_file_name = sanitized_filename(image_file_name)
+            end
+
+            # Create important thumbnails upfront
+            after_create -> { PictureThumb.generate_thumbs!(self) },
+              if: :has_convertible_format?
+          end
+        end
+      end
+
+      module AttachmentClassMethods
+        def self.included(base)
+          base.class_eval do
+            dragonfly_accessor :file, app: :alchemy_attachments do
+              after_assign { |file|
+                write_attribute(:file_mime_type, file.mime_type)
+              }
+            end
+
+            before_save do
+              self.file_name = sanitized_filename(file_name)
+            end
+          end
+        end
+      end
+
+      extend self
+
+      CONVERTIBLE_FILE_FORMATS = %w[gif jpg jpeg png webp].freeze
+
+      # Allows to set a custom Attachment Url class
+      def attachment_url_class=(klass)
+        @_attachment_url_class = klass
+      end
+
+      # Returns the class used to generate attachment urls
+      # @return [Class] - defaults to Alchemy::StorageAdapter::Dragonfly::AttachmentUrl
+      def attachment_url_class
+        @_attachment_url_class ||= AttachmentUrl
+      end
+
+      def preprocessor_class
+        Preprocessor
+      end
+
+      # Allows to set a custom Picture Url class
+      def picture_url_class=(klass)
+        @_picture_url_class = klass
+      end
+
+      # Returns the class used to generate picture urls
+      # @return [Class] - defaults to Alchemy::StorageAdapter::Dragonfly::PictureUrl
+      def picture_url_class
+        @_picture_url_class ||= PictureUrl
+      end
+
+      def file_formats(class_name, scope:)
+        mime_type_column = case class_name
+        when "Alchemy::Attachment" then :file_mime_type
+        when "Alchemy::Picture" then :image_file_format
+        end
+
+        scope.reorder(mime_type_column).distinct.pluck(mime_type_column).compact.presence || []
+      end
+
+      # @param [String]
+      # @return [Array<String>]
+      def searchable_alchemy_resource_attributes(class_name)
+        case class_name
+        when "Alchemy::Attachment"
+          %w[name file_name]
+        when "Alchemy::Picture"
+          %w[name image_file_name]
+        end
+      end
+      alias_method :ransackable_attributes, :searchable_alchemy_resource_attributes
+
+      # @param [String]
+      # @return [Array<String>]
+      def ransackable_associations(_class_name)
+        %w[]
+      end
+
+      def rescuable_errors
+        ::Dragonfly::Job::Fetch::NotFound
+      end
+
+      # @param [String]
+      # @return [Alchemy::Picture::ActiveRecord_Relation]
+      def by_file_format_scope(file_format)
+        Picture.where(image_file_format: file_format)
+      end
+
+      # @param [String]
+      # @return [Alchemy::Attachment::ActiveRecord_Relation]
+      def by_file_type_scope(file_type)
+        Attachment.where(file_mime_type: file_type)
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [String]
+      def file_name(attachment)
+        attachment.read_attribute(:file_name)
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [Integer]
+      def file_size(attachment)
+        attachment.read_attribute(:file_size)
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [String]
+      def file_mime_type(attachment)
+        attachment.read_attribute(:file_mime_type)
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [String]
+      def file_extension(attachment)
+        content_type = file_mime_type(attachment)
+        Marcel::Magic.new(content_type).extensions.first if content_type
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [TrueClass, FalseClass]
+      def has_convertible_format?(picture)
+        image_file_extension(picture).in?(CONVERTIBLE_FILE_FORMATS)
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [String]
+      def image_file_name(picture)
+        picture.read_attribute(:image_file_name)
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [String]
+      def image_file_format(picture)
+        ext = picture.read_attribute(:image_file_format)
+        Marcel::MimeType.for(extension: ext) if ext
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [Integer]
+      def image_file_size(picture)
+        picture.read_attribute(:image_file_size)
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [Integer]
+      def image_file_width(picture)
+        picture.read_attribute(:image_file_width)
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [Integer]
+      def image_file_height(picture)
+        picture.read_attribute(:image_file_height)
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [String]
+      def image_file_extension(picture)
+        picture.read_attribute(:image_file_format)
+      end
+
+      # @param [Alchemy::Picture]
+      # @return [TrueClass, FalseClass]
+      def image_file_present?(picture)
+        !!picture.image_file
+      end
+
+      # @param Alchemy::Picture::ActiveRecord_Relation
+      # @return Alchemy::Picture::ActiveRecord_Relation
+      def preloaded_pictures(pictures)
+        pictures.includes(:thumbs)
+      end
+
+      # @param [Alchemy::Attachment]
+      # @return [TrueClass, FalseClass]
+      def set_attachment_name?(attachment)
+        attachment.file_name_changed?
+      end
+    end
+  end
+end

data/app/models/alchemy/storage_adapter.rb

@@ -0,0 +1,74 @@
+module Alchemy
+  class StorageAdapter
+    class UnknownAdapterError < StandardError; end
+
+    attr_reader :name, :adapter
+
+    delegate(
+      :attachment_url_class,
+      :by_file_format_scope,
+      :by_file_type_scope,
+      :file_extension,
+      :file_formats,
+      :file_mime_type,
+      :file_name,
+      :file_size,
+      :has_convertible_format?,
+      :image_file_extension,
+      :image_file_format,
+      :image_file_height,
+      :image_file_name,
+      :image_file_present?,
+      :image_file_size,
+      :image_file_width,
+      :picture_url_class,
+      :preloaded_pictures,
+      :preprocessor_class,
+      :ransackable_associations,
+      :ransackable_attributes,
+      :rescuable_errors,
+      :searchable_alchemy_resource_attributes,
+      :set_attachment_name?,
+      to: :adapter
+    )
+
+    def initialize(name)
+      @name = name.to_sym
+      @adapter = adapter_class
+    end
+
+    def ==(other)
+      name == other.to_sym
+    end
+
+    def active_storage?
+      name == :active_storage
+    end
+
+    def dragonfly?
+      name == :dragonfly
+    end
+
+    def picture_class_methods
+      adapter::PictureClassMethods
+    end
+
+    def attachment_class_methods
+      adapter::AttachmentClassMethods
+    end
+
+    private
+
+    def adapter_class
+      case name
+      when :active_storage
+        ActiveStorage
+      when :dragonfly
+        Dragonfly
+      else
+        raise UnknownAdapterError,
+          "Unknown storage adapter: #{name}. Please use either 'active_storage' or 'dragonfly'."
+      end
+    end
+  end
+end

data/app/models/concerns/alchemy/picture_thumbnails.rb

@@ -28,7 +28,7 @@ module Alchemy
     #
     # @option options format [String]
     #   The format the picture should be rendered in.
-    #   Defaults to the +image_output_format+ from the +Alchemy::Config+.
+    #   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.
@@ -84,7 +84,7 @@ module Alchemy
         crop_from: crop && crop_from.presence || default_crop_from&.join("x"),
         crop_size: crop && crop_size.presence || default_crop_size&.join("x"),
         flatten: true,
-        format: picture&.image_file_format || "jpg"
+        format: picture&.image_file_extension || "jpg"
       }
     end
 
@@ -102,14 +102,27 @@ module Alchemy
 
     # Show image cropping link for ingredient
     def allow_image_cropping?
-      settings[:crop] && picture&.can_be_cropped_to?(
-        settings[:size],
-        settings[:upsample]
-      ) && !!picture.image_file
+      settings[:crop] && picture &&
+        Alchemy.storage_adapter.image_file_present?(picture) &&
+        can_be_cropped_to?
     end
 
     private
 
+    # An Image smaller than dimensions
+    # can not be cropped to given size - unless upsample is true.
+    #
+    def can_be_cropped_to?
+      return true if settings[:upsample]
+
+      dimensions = inferred_dimensions_from_string(settings[:size])
+      if dimensions
+        picture.image_file_width > dimensions[0] && picture.image_file_height > dimensions[1]
+      else
+        false
+      end
+    end
+
     def default_crop_size
       return nil unless settings[:crop] && settings[:size]