Add storage adapter

Author: tvdeyen

app/models/alchemy/attachment.rb

@@ -114,9 +114,7 @@ def allowed_filetypes
       private
 
       def file_types
-        ActiveStorage::Blob.joins(:attachments).merge(
-          ActiveStorage::Attachment.where(record_type: name)
-        ).distinct.pluck(:content_type)
+        Alchemy.storage_adapter.file_formats(name)
       end
     end
 

app/models/alchemy/picture.rb

@@ -28,17 +28,6 @@ class Picture < BaseRecord
       large: "240x180"
     }.with_indifferent_access.freeze
 
-    TRANSFORMATION_OPTIONS = [
-      :crop,
-      :crop_from,
-      :crop_size,
-      :flatten,
-      :format,
-      :quality,
-      :size,
-      :upsample
-    ]
-
     include Alchemy::Logger
     include Alchemy::NameConversions
     include Alchemy::Taggable
@@ -68,7 +57,7 @@ class Picture < BaseRecord
 
     # Image preprocessing class
     def self.preprocessor_class
-      @_preprocessor_class ||= Preprocessor
+      @_preprocessor_class ||= Alchemy.storage_adapter.preprocessor_class
     end
 
     # Set a image preprocessing class
@@ -80,31 +69,7 @@ def self.preprocessor_class=(klass)
       @_preprocessor_class = klass
     end
 
-    attr_readonly(
-      :legacy_image_file_format,
-      :legacy_image_file_height,
-      :legacy_image_file_name,
-      :legacy_image_file_size,
-      :legacy_image_file_uid,
-      :legacy_image_file_width
-    )
-
-    deprecate(
-      :legacy_image_file_format,
-      :legacy_image_file_height,
-      :legacy_image_file_name,
-      :legacy_image_file_size,
-      :legacy_image_file_uid,
-      :legacy_image_file_width,
-      deprecator: Alchemy::Deprecation
-    )
-
-    # Use ActiveStorage image processing
-    has_one_attached :image_file do |attachable|
-      # Only works in Rails 7.1
-      preprocessor_class.new(attachable).call
-      Preprocessor.generate_thumbs!(attachable)
-    end
+    include Alchemy.storage_adapter.picture_class_methods
 
     validates_presence_of :image_file
     validate :image_file_type_allowed, :image_file_not_too_big,
@@ -131,7 +96,7 @@ class << self
       #
       # @see Alchemy::Picture::Url
       def url_class
-        @_url_class ||= Alchemy::Picture::Url
+        @_url_class ||= Alchemy.storage_adapter.url_class
       end
 
       # Set a different picture url class
@@ -177,9 +142,7 @@ def last_upload
       private
 
       def file_formats
-        ActiveStorage::Blob.joins(:attachments).merge(
-          ActiveStorage::Attachment.where(record_type: name)
-        ).distinct.pluck(:content_type)
+        Alchemy.storage_adapter.picture_file_formats
       end
     end
 
@@ -196,7 +159,7 @@ def url(options = {})
       return unless image_file
 
       self.class.url_class.new(self).call(options)
-    rescue ::ActiveStorage::Error => e
+    rescue Alchemy.storage_adapter.rescuable_errors => e
       log_warning(e.message)
       nil
     end
@@ -280,7 +243,7 @@ def convertible?
     # Returns true if the image can be converted into other formats
     #
     def has_convertible_format?
-      image_file&.variable?
+      Alchemy.storage_adapter.has_convertible_format?(self)
     end
 
     # Checks if the picture is restricted.
@@ -302,27 +265,27 @@ def deletable?
     end
 
     def image_file_name
-      image_file&.filename&.to_s
+      Alchemy.storage_adapter.image_file_name(self)
     end
 
     def image_file_format
-      image_file&.content_type
+      Alchemy.storage_adapter.image_file_format(self)
     end
 
     def image_file_size
-      image_file&.byte_size
+      Alchemy.storage_adapter.image_file_size(self)
     end
 
     def image_file_width
-      image_file&.metadata&.fetch(:width, nil)
+      Alchemy.storage_adapter.image_file_width(self)
     end
 
     def image_file_height
-      image_file&.metadata&.fetch(:height, nil)
+      Alchemy.storage_adapter.image_file_height(self)
     end
 
     def image_file_extension
-      image_file&.filename&.extension&.downcase
+      Alchemy.storage_adapter.image_file_extension(self)
     end
 
     alias_method :suffix, :image_file_extension

app/models/alchemy/picture/active_storage_preprocessor.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class Picture < BaseRecord
+    class ActiveStoragePreprocessor
+      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
+
+        private
+
+        def process_thumb(attachable, options = {})
+          attachable.variant :thumb,
+            **Alchemy::DragonflyToImageProcessing.call(options),
+            preprocessed: true
+        end
+      end
+    end
+  end
+end

app/models/alchemy/picture/active_storage_url.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Alchemy
+  class Picture < BaseRecord
+    # Returns the URL to a variant of a picture using ActiveStorage
+    class ActiveStorageUrl
+      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.get(:image_output_format) == "original"
+          picture.image_file_extension
+        else
+          Alchemy::Config.get(:image_output_format)
+        end
+      end
+    end
+  end
+end

app/models/alchemy/picture/preprocessor.rb

@@ -3,8 +3,8 @@
 module Alchemy
   class Picture < BaseRecord
     class Preprocessor
-      def initialize(attachable)
-        @attachable = attachable
+      def initialize(image_file)
+        @image_file = image_file
       end
 
       # Preprocess images after upload
@@ -15,28 +15,14 @@ def initialize(attachable)
       #
       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
+        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!
       end
 
-      attr_reader :attachable
+      private
 
-      class << self
-        def generate_thumbs!(attachable)
-          Alchemy::Picture::THUMBNAIL_SIZES.values.each do |size|
-            process_thumb(attachable, size: size, flatten: true)
-          end
-        end
-
-        private
-
-        def process_thumb(attachable, options = {})
-          attachable.variant :thumb,
-            **Alchemy::DragonflyToImageProcessing.call(options),
-            preprocessed: true
-        end
-      end
+      attr_reader :image_file
     end
   end
 end

app/models/alchemy/picture/url.rb

@@ -3,50 +3,66 @@
 module Alchemy
   class Picture < BaseRecord
     class Url
-      attr_reader :picture, :image_file
+      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
-        @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
-          }
+        @variant = PictureVariant.new(picture, options.slice(*TRANSFORMATION_OPTIONS))
+        params = options.except(*TRANSFORMATION_OPTIONS).merge(
+          basename: picture.name,
+          ext: variant.render_format,
+          name: picture.name
         )
+
+        return variant.image.url(params) unless processible_image?
+
+        "/#{uid}"
       end
 
       private
 
-      def filename(options = {})
-        if picture.name.presence
-          picture.name.to_param
+      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
-          picture.image_file_name
+          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 default_output_format
-        if Alchemy::Config.get(:image_output_format) == "original"
-          picture.image_file_extension
+      def find_thumb_by(signature)
+        @thumb = if picture.thumbs.loaded?
+          picture.thumbs.find { |t| t.signature == signature }
         else
-          Alchemy::Config.get(:image_output_format)
+          picture.thumbs.find_by(signature: signature)
         end
       end
     end