activestorage 6.1.7 → 7.0.0

data/lib/active_storage/analyzer/image_analyzer/image_magick.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # This analyzer relies on the third-party {MiniMagick}[https://github.com/minimagick/minimagick] gem. MiniMagick requires
+  # the {ImageMagick}[http://www.imagemagick.org] system library.
+  class Analyzer::ImageAnalyzer::ImageMagick < Analyzer::ImageAnalyzer
+    def self.accept?(blob)
+      super && ActiveStorage.variant_processor == :mini_magick
+    end
+
+    private
+      def read_image
+        download_blob_to_tempfile do |file|
+          require "mini_magick"
+
+          image = instrument("mini_magick") do
+            MiniMagick::Image.new(file.path)
+          end
+
+          if image.valid?
+            yield image
+          else
+            logger.info "Skipping image analysis because ImageMagick doesn't support the file"
+            {}
+          end
+        end
+      rescue LoadError
+        logger.info "Skipping image analysis because the mini_magick gem isn't installed"
+        {}
+      rescue MiniMagick::Error => error
+        logger.error "Skipping image analysis due to an ImageMagick error: #{error.message}"
+        {}
+      end
+
+      def rotated_image?(image)
+        %w[ RightTop LeftBottom TopRight BottomLeft ].include?(image["%[orientation]"])
+      end
+  end
+end

data/lib/active_storage/analyzer/image_analyzer/vips.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # This analyzer relies on the third-party {ruby-vips}[https://github.com/libvips/ruby-vips] gem. Ruby-vips requires
+  # the {libvips}[https://libvips.github.io/libvips/] system library.
+  class Analyzer::ImageAnalyzer::Vips < Analyzer::ImageAnalyzer
+    def self.accept?(blob)
+      super && ActiveStorage.variant_processor == :vips
+    end
+
+    private
+      def read_image
+        download_blob_to_tempfile do |file|
+          require "ruby-vips"
+
+          image = instrument("vips") do
+            ::Vips::Image.new_from_file(file.path, access: :sequential)
+          end
+
+          if valid_image?(image)
+            yield image
+          else
+            logger.info "Skipping image analysis because Vips doesn't support the file"
+            {}
+          end
+        end
+      rescue LoadError
+        logger.info "Skipping image analysis because the ruby-vips gem isn't installed"
+        {}
+      rescue ::Vips::Error => error
+        logger.error "Skipping image analysis due to an Vips error: #{error.message}"
+        {}
+      end
+
+      ROTATIONS = /Right-top|Left-bottom|Top-right|Bottom-left/
+      def rotated_image?(image)
+        ROTATIONS === image.get("exif-ifd0-Orientation")
+      rescue ::Vips::Error
+        false
+      end
+
+      def valid_image?(image)
+        image.avg
+        true
+      rescue ::Vips::Error
+        false
+      end
+  end
+end

data/lib/active_storage/analyzer/image_analyzer.rb

@@ -1,17 +1,14 @@
 # frozen_string_literal: true
 
 module ActiveStorage
-  # Extracts width and height in pixels from an image blob.
+  # This is an abstract base class for image analyzers, which extract width and height from an image blob.
   #
   # If the image contains EXIF data indicating its angle is 90 or 270 degrees, its width and height are swapped for convenience.
   #
   # Example:
   #
-  #   ActiveStorage::Analyzer::ImageAnalyzer.new(blob).metadata
+  #   ActiveStorage::Analyzer::ImageAnalyzer::ImageMagick.new(blob).metadata
   #   # => { width: 4104, height: 2736 }
-  #
-  # This analyzer relies on the third-party {MiniMagick}[https://github.com/minimagick/minimagick] gem. MiniMagick requires
-  # the {ImageMagick}[http://www.imagemagick.org] system library.
   class Analyzer::ImageAnalyzer < Analyzer
     def self.accept?(blob)
       blob.image?
@@ -26,30 +23,5 @@ module ActiveStorage
         end
       end
     end
-
-    private
-      def read_image
-        download_blob_to_tempfile do |file|
-          require "mini_magick"
-          image = MiniMagick::Image.new(file.path)
-
-          if image.valid?
-            yield image
-          else
-            logger.info "Skipping image analysis because ImageMagick doesn't support the file"
-            {}
-          end
-        end
-      rescue LoadError
-        logger.info "Skipping image analysis because the mini_magick gem isn't installed"
-        {}
-      rescue MiniMagick::Error => error
-        logger.error "Skipping image analysis due to an ImageMagick error: #{error.message}"
-        {}
-      end
-
-      def rotated_image?(image)
-        %w[ RightTop LeftBottom ].include?(image["%[orientation]"])
-      end
   end
 end

data/lib/active_storage/analyzer/video_analyzer.rb

@@ -8,11 +8,13 @@ module ActiveStorage
   # * Duration (seconds)
   # * Angle (degrees)
   # * Display aspect ratio
+  # * Audio (true if file has an audio channel, false if not)
+  # * Video (true if file has an video channel, false if not)
   #
   # Example:
   #
   #   ActiveStorage::Analyzer::VideoAnalyzer.new(blob).metadata
-  #   # => { width: 640.0, height: 480.0, duration: 5.0, angle: 0, display_aspect_ratio: [4, 3] }
+  #   # => { width: 640.0, height: 480.0, duration: 5.0, angle: 0, display_aspect_ratio: [4, 3], audio: true, video: true }
   #
   # When a video's angle is 90 or 270 degrees, its width and height are automatically swapped for convenience.
   #
@@ -23,7 +25,7 @@ module ActiveStorage
     end
 
     def metadata
-      { width: width, height: height, duration: duration, angle: angle, display_aspect_ratio: display_aspect_ratio }.compact
+      { width: width, height: height, duration: duration, angle: angle, display_aspect_ratio: display_aspect_ratio, audio: audio?, video: video? }.compact
     end
 
     private
@@ -63,11 +65,18 @@ module ActiveStorage
         end
       end
 
-
       def rotated?
         angle == 90 || angle == 270
       end
 
+      def audio?
+        audio_stream.present?
+      end
+
+      def video?
+        video_stream.present?
+      end
+
       def computed_height
         if encoded_width && display_height_scale
           encoded_width * display_height_scale
@@ -95,6 +104,10 @@ module ActiveStorage
         @video_stream ||= streams.detect { |stream| stream["codec_type"] == "video" } || {}
       end
 
+      def audio_stream
+        @audio_stream ||= streams.detect { |stream| stream["codec_type"] == "audio" } || {}
+      end
+
       def streams
         probe["streams"] || []
       end
@@ -108,14 +121,16 @@ module ActiveStorage
       end
 
       def probe_from(file)
-        IO.popen([ ffprobe_path,
-          "-print_format", "json",
-          "-show_streams",
-          "-show_format",
-          "-v", "error",
-          file.path
-        ]) do |output|
-          JSON.parse(output.read)
+        instrument(File.basename(ffprobe_path)) do
+          IO.popen([ ffprobe_path,
+            "-print_format", "json",
+            "-show_streams",
+            "-show_format",
+            "-v", "error",
+            file.path
+          ]) do |output|
+            JSON.parse(output.read)
+          end
         end
       rescue Errno::ENOENT
         logger.info "Skipping video analysis because FFmpeg isn't installed"

data/lib/active_storage/analyzer.rb

@@ -2,7 +2,7 @@
 
 module ActiveStorage
   # This is an abstract base class for analyzers, which extract metadata from blobs. See
-  # ActiveStorage::Analyzer::ImageAnalyzer for an example of a concrete subclass.
+  # ActiveStorage::Analyzer::VideoAnalyzer for an example of a concrete subclass.
   class Analyzer
     attr_reader :blob
 
@@ -29,16 +29,20 @@ module ActiveStorage
 
     private
       # Downloads the blob to a tempfile on disk. Yields the tempfile.
-      def download_blob_to_tempfile(&block) #:doc:
+      def download_blob_to_tempfile(&block) # :doc:
         blob.open tmpdir: tmpdir, &block
       end
 
-      def logger #:doc:
+      def logger # :doc:
         ActiveStorage.logger
       end
 
-      def tmpdir #:doc:
+      def tmpdir # :doc:
         Dir.tmpdir
       end
+
+      def instrument(analyzer, &block) # :doc:
+        ActiveSupport::Notifications.instrument("analyze.active_storage", analyzer: analyzer, &block)
+      end
   end
 end

data/lib/active_storage/attached/changes/create_many.rb

@@ -1,12 +1,13 @@
 # frozen_string_literal: true
 
 module ActiveStorage
-  class Attached::Changes::CreateMany #:nodoc:
+  class Attached::Changes::CreateMany # :nodoc:
     attr_reader :name, :record, :attachables
 
     def initialize(name, record, attachables)
       @name, @record, @attachables = name, record, Array(attachables)
       blobs.each(&:identify_without_saving)
+      attachments
     end
 
     def attachments
@@ -35,13 +36,16 @@ module ActiveStorage
         ActiveStorage::Attached::Changes::CreateOneOfMany.new(name, record, attachable)
       end
 
-
       def assign_associated_attachments
-        record.public_send("#{name}_attachments=", attachments)
+        record.public_send("#{name}_attachments=", persisted_or_new_attachments)
       end
 
       def reset_associated_blobs
         record.public_send("#{name}_blobs").reset
       end
+
+      def persisted_or_new_attachments
+        attachments.select { |attachment| attachment.persisted? || attachment.new_record? }
+      end
   end
 end

data/lib/active_storage/attached/changes/create_one.rb

@@ -4,7 +4,7 @@ require "action_dispatch"
 require "action_dispatch/http/upload"
 
 module ActiveStorage
-  class Attached::Changes::CreateOne #:nodoc:
+  class Attached::Changes::CreateOne # :nodoc:
     attr_reader :name, :record, :attachable
 
     def initialize(name, record, attachable)

data/lib/active_storage/attached/changes/create_one_of_many.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveStorage
-  class Attached::Changes::CreateOneOfMany < Attached::Changes::CreateOne #:nodoc:
+  class Attached::Changes::CreateOneOfMany < Attached::Changes::CreateOne # :nodoc:
     private
       def find_attachment
         record.public_send("#{name}_attachments").detect { |attachment| attachment.blob_id == blob.id }

data/lib/active_storage/attached/changes/delete_many.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveStorage
-  class Attached::Changes::DeleteMany #:nodoc:
+  class Attached::Changes::DeleteMany # :nodoc:
     attr_reader :name, :record
 
     def initialize(name, record)

data/lib/active_storage/attached/changes/delete_one.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveStorage
-  class Attached::Changes::DeleteOne #:nodoc:
+  class Attached::Changes::DeleteOne # :nodoc:
     attr_reader :name, :record
 
     def initialize(name, record)

data/lib/active_storage/attached/changes/detach_many.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::DetachMany # :nodoc:
+    attr_reader :name, :record, :attachments
+
+    def initialize(name, record, attachments)
+      @name, @record, @attachments = name, record, attachments
+    end
+
+    def detach
+      if attachments.any?
+        attachments.delete_all if attachments.respond_to?(:delete_all)
+        record.attachment_changes.delete(name)
+      end
+    end
+  end
+end

data/lib/active_storage/attached/changes/detach_one.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::DetachOne # :nodoc:
+    attr_reader :name, :record, :attachment
+
+    def initialize(name, record, attachment)
+      @name, @record, @attachment = name, record, attachment
+    end
+
+    def detach
+      if attachment.present?
+        attachment.delete
+        reset
+      end
+    end
+
+    private
+      def reset
+        record.attachment_changes.delete(name)
+        record.public_send("#{name}_attachment=", nil)
+      end
+  end
+end

data/lib/active_storage/attached/changes/purge_many.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::PurgeMany # :nodoc:
+    attr_reader :name, :record, :attachments
+
+    def initialize(name, record, attachments)
+      @name, @record, @attachments = name, record, attachments
+    end
+
+    def purge
+      attachments.each(&:purge)
+      reset
+    end
+
+    def purge_later
+      attachments.each(&:purge_later)
+      reset
+    end
+
+    private
+      def reset
+        record.attachment_changes.delete(name)
+        record.public_send("#{name}_attachments").reset
+      end
+  end
+end

data/lib/active_storage/attached/changes/purge_one.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Attached::Changes::PurgeOne # :nodoc:
+    attr_reader :name, :record, :attachment
+
+    def initialize(name, record, attachment)
+      @name, @record, @attachment = name, record, attachment
+    end
+
+    def purge
+      attachment&.purge
+      reset
+    end
+
+    def purge_later
+      attachment&.purge_later
+      reset
+    end
+
+    private
+      def reset
+        record.attachment_changes.delete(name)
+        record.public_send("#{name}_attachment=", nil)
+      end
+  end
+end

data/lib/active_storage/attached/changes.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
 module ActiveStorage
-  module Attached::Changes #:nodoc:
+  module Attached::Changes # :nodoc:
     extend ActiveSupport::Autoload
 
     eager_autoload do
@@ -11,6 +11,12 @@ module ActiveStorage
 
       autoload :DeleteOne
       autoload :DeleteMany
+
+      autoload :DetachOne
+      autoload :DetachMany
+
+      autoload :PurgeOne
+      autoload :PurgeMany
     end
   end
 end

data/lib/active_storage/attached/many.rb

@@ -3,6 +3,25 @@
 module ActiveStorage
   # Decorated proxy object representing of multiple attachments to a model.
   class Attached::Many < Attached
+    ##
+    # :method: purge
+    #
+    # Directly purges each associated attachment (i.e. destroys the blobs and
+    # attachments and deletes the files on the service).
+    delegate :purge, to: :purge_many
+
+    ##
+    # :method: purge_later
+    #
+    # Purges each associated attachment through the queuing system.
+    delegate :purge_later, to: :purge_many
+
+    ##
+    # :method: detach
+    #
+    # Deletes associated attachments without purging them, leaving their respective blobs in place.
+    delegate :detach, to: :detach_many
+
     delegate_missing_to :attachments
 
     # Returns all the associated attachment records.
@@ -25,7 +44,7 @@ module ActiveStorage
     #
     #   document.images.attach(params[:images]) # Array of ActionDispatch::Http::UploadedFile objects
     #   document.images.attach(params[:signed_blob_id]) # Signed reference to blob from direct upload
-    #   document.images.attach(io: File.open("/path/to/racecar.jpg"), filename: "racecar.jpg", content_type: "image/jpg")
+    #   document.images.attach(io: File.open("/path/to/racecar.jpg"), filename: "racecar.jpg", content_type: "image/jpeg")
     #   document.images.attach([ first_blob, second_blob ])
     def attach(*attachables)
       if record.persisted? && !record.changed?
@@ -47,20 +66,13 @@ module ActiveStorage
       attachments.any?
     end
 
-    # Deletes associated attachments without purging them, leaving their respective blobs in place.
-    def detach
-      attachments.delete_all if attached?
-    end
-
-    ##
-    # :method: purge
-    #
-    # Directly purges each associated attachment (i.e. destroys the blobs and
-    # attachments and deletes the files on the service).
+    private
+      def purge_many
+        Attached::Changes::PurgeMany.new(name, record, attachments)
+      end
 
-    ##
-    # :method: purge_later
-    #
-    # Purges each associated attachment through the queuing system.
+      def detach_many
+        Attached::Changes::DetachMany.new(name, record, attachments)
+      end
   end
 end

data/lib/active_storage/attached/model.rb

@@ -83,6 +83,7 @@ module ActiveStorage
           { dependent: dependent, service_name: service },
           self
         )
+        yield reflection if block_given?
         ActiveRecord::Reflection.add_attachment_reflection(self, name, reflection)
       end
 
@@ -136,15 +137,23 @@ module ActiveStorage
           end
 
           def #{name}=(attachables)
+            attachables = Array(attachables).compact_blank
+
             if ActiveStorage.replace_on_assign_to_many
               attachment_changes["#{name}"] =
-                if Array(attachables).none?
+                if attachables.none?
                   ActiveStorage::Attached::Changes::DeleteMany.new("#{name}", self)
                 else
                   ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, attachables)
                 end
             else
-              if Array(attachables).any?
+              ActiveSupport::Deprecation.warn \
+                "config.active_storage.replace_on_assign_to_many is deprecated and will be removed in Rails 7.1. " \
+                "Make sure that your code works well with config.active_storage.replace_on_assign_to_many set to true before upgrading. " \
+                "To append new attachables to the Active Storage association, prefer using `attach`. " \
+                "Using association setter would result in purging the existing attached attachments and replacing them with new ones."
+
+              if attachables.any?
                 attachment_changes["#{name}"] =
                   ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, #{name}.blobs + attachables)
               end
@@ -154,18 +163,36 @@ module ActiveStorage
 
         has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "ActiveStorage::Attachment", inverse_of: :record, dependent: :destroy, strict_loading: strict_loading do
           def purge
+            deprecate(:purge)
             each(&:purge)
             reset
           end
 
           def purge_later
+            deprecate(:purge_later)
             each(&:purge_later)
             reset
           end
+
+          private
+          def deprecate(action)
+            reflection_name = proxy_association.reflection.name
+            attached_name = reflection_name.to_s.partition("_").first
+            ActiveSupport::Deprecation.warn(<<-MSG.squish)
+              Calling `#{action}` from `#{reflection_name}` is deprecated and will be removed in Rails 7.1.
+              To migrate to Rails 7.1's behavior call `#{action}` from `#{attached_name}` instead: `#{attached_name}.#{action}`.
+            MSG
+          end
         end
         has_many :"#{name}_blobs", through: :"#{name}_attachments", class_name: "ActiveStorage::Blob", source: :blob, strict_loading: strict_loading
 
-        scope :"with_attached_#{name}", -> { includes("#{name}_attachments": :blob) }
+        scope :"with_attached_#{name}", -> {
+          if ActiveStorage.track_variants
+            includes("#{name}_attachments": { blob: :variant_records })
+          else
+            includes("#{name}_attachments": :blob)
+          end
+        }
 
         after_save { attachment_changes[name.to_s]&.save }
 
@@ -178,6 +205,7 @@ module ActiveStorage
           { dependent: dependent, service_name: service },
           self
         )
+        yield reflection if block_given?
         ActiveRecord::Reflection.add_attachment_reflection(self, name, reflection)
       end
 
@@ -191,21 +219,21 @@ module ActiveStorage
         end
     end
 
-    def attachment_changes #:nodoc:
+    def attachment_changes # :nodoc:
       @attachment_changes ||= {}
     end
 
-    def changed_for_autosave? #:nodoc:
+    def changed_for_autosave? # :nodoc:
       super || attachment_changes.any?
     end
 
-    def initialize_dup(*) #:nodoc:
+    def initialize_dup(*) # :nodoc:
       super
       @active_storage_attached = nil
       @attachment_changes = nil
     end
 
-    def reload(*) #:nodoc:
+    def reload(*) # :nodoc:
       super.tap { @attachment_changes = nil }
     end
   end