activestorage 7.0.8 → 7.1.0

data/app/models/active_storage/variant.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# = Active Storage \Variant
+#
 # Image blobs can have variants that are the result of a set of transformations applied to the original.
 # These variants are used to create thumbnails, fixed-size avatars, or any other derivative image from the
 # original.
@@ -72,7 +74,7 @@ class ActiveStorage::Variant
 
   # Returns the URL of the blob variant on the service. See {ActiveStorage::Blob#url} for details.
   #
-  # Use <tt>url_for(variant)</tt> (or the implied form, like +link_to variant+ or +redirect_to variant+) to get the stable URL
+  # Use <tt>url_for(variant)</tt> (or the implied form, like <tt>link_to variant</tt> or <tt>redirect_to variant</tt>) to get the stable URL
   # for a variant that points to the ActiveStorage::RepresentationsController, which in turn will use this +service_call+ method
   # for its redirection.
   def url(expires_in: ActiveStorage.service_urls_expire_in, disposition: :inline)
@@ -89,17 +91,16 @@ class ActiveStorage::Variant
     ActiveStorage::Filename.new "#{blob.filename.base}.#{variation.format.downcase}"
   end
 
-  alias_method :content_type_for_serving, :content_type
-
-  def forced_disposition_for_serving # :nodoc:
-    nil
-  end
-
   # Returns the receiving variant. Allows ActiveStorage::Variant and ActiveStorage::Preview instances to be used interchangeably.
   def image
     self
   end
 
+  # Deletes variant file from service.
+  def destroy
+    service.delete(key)
+  end
+
   private
     def processed?
       service.exist?(key)

data/app/models/active_storage/variant_with_record.rb

@@ -1,35 +1,47 @@
 # frozen_string_literal: true
 
+# = Active Storage \Variant With Record
+#
 # Like an ActiveStorage::Variant, but keeps detail about the variant in the database as an
 # ActiveStorage::VariantRecord. This is only used if +ActiveStorage.track_variants+ is enabled.
 class ActiveStorage::VariantWithRecord
   attr_reader :blob, :variation
   delegate :service, to: :blob
+  delegate :content_type, to: :variation
 
   def initialize(blob, variation)
     @blob, @variation = blob, ActiveStorage::Variation.wrap(variation)
   end
 
   def processed
-    process
+    process unless processed?
     self
   end
 
-  def process
-    transform_blob { |image| create_or_find_record(image: image) } unless processed?
+  def image
+    record&.image
   end
 
-  def processed?
-    record.present?
+  def filename
+    ActiveStorage::Filename.new "#{blob.filename.base}.#{variation.format.downcase}"
   end
 
-  def image
-    record&.image
+  # Destroys record and deletes file from service.
+  def destroy
+    record&.destroy
   end
 
   delegate :key, :url, :download, to: :image, allow_nil: true
 
   private
+    def processed?
+      record.present?
+    end
+
+    def process
+      transform_blob { |image| create_or_find_record(image: image) }
+    end
+
     def transform_blob
       blob.open do |input|
         variation.transform(input) do |output|

data/app/models/active_storage/variation.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-require "mini_mime"
+require "marcel"
 
+# = Active Storage \Variation
+#
 # A set of transformations that can be applied to a blob to create a variant. This class is exposed via
 # the ActiveStorage::Blob#variant method and should rarely be used directly.
 #
@@ -59,14 +61,14 @@ class ActiveStorage::Variation
 
   def format
     transformations.fetch(:format, :png).tap do |format|
-      if MiniMime.lookup_by_extension(format.to_s).nil?
+      if Marcel::Magic.by_extension(format.to_s).nil?
         raise ArgumentError, "Invalid variant format (#{format.inspect})"
       end
     end
   end
 
   def content_type
-    MiniMime.lookup_by_extension(format.to_s).content_type
+    Marcel::MimeType.for(extension: format.to_s)
   end
 
   # Returns a signed key for all the +transformations+ that this variation was instantiated with.

data/config/routes.rb

@@ -32,16 +32,17 @@ Rails.application.routes.draw do
 
   direct :rails_storage_proxy do |model, options|
     expires_in = options.delete(:expires_in) { ActiveStorage.urls_expire_in }
+    expires_at = options.delete(:expires_at)
 
     if model.respond_to?(:signed_id)
       route_for(
         :rails_service_blob_proxy,
-        model.signed_id(expires_in: expires_in),
+        model.signed_id(expires_in: expires_in, expires_at: expires_at),
         model.filename,
         options
       )
     else
-      signed_blob_id = model.blob.signed_id(expires_in: expires_in)
+      signed_blob_id = model.blob.signed_id(expires_in: expires_in, expires_at: expires_at)
       variation_key  = model.variation.key
       filename       = model.blob.filename
 
@@ -57,16 +58,17 @@ Rails.application.routes.draw do
 
   direct :rails_storage_redirect do |model, options|
     expires_in = options.delete(:expires_in) { ActiveStorage.urls_expire_in }
+    expires_at = options.delete(:expires_at)
 
     if model.respond_to?(:signed_id)
       route_for(
         :rails_service_blob,
-        model.signed_id(expires_in: expires_in),
+        model.signed_id(expires_in: expires_in, expires_at: expires_at),
         model.filename,
         options
       )
     else
-      signed_blob_id = model.blob.signed_id(expires_in: expires_in)
+      signed_blob_id = model.blob.signed_id(expires_in: expires_in, expires_at: expires_at)
       variation_key  = model.variation.key
       filename       = model.blob.filename
 

data/db/migrate/20170806125915_create_active_storage_tables.rb

@@ -1,4 +1,4 @@
-class CreateActiveStorageTables < ActiveRecord::Migration[5.2]
+class CreateActiveStorageTables < ActiveRecord::Migration[7.0]
   def change
     # Use Active Record's configured type for primary and foreign keys
     primary_key_type, foreign_key_type = primary_and_foreign_key_types

data/lib/active_storage/analyzer/audio_analyzer.rb

@@ -1,21 +1,23 @@
 # frozen_string_literal: true
 
 module ActiveStorage
-  # Extracts duration (seconds) and bit_rate (bits/s) from an audio blob.
+  # = Active Storage Audio \Analyzer
+  #
+  # Extracts duration (seconds), bit_rate (bits/s), sample_rate (hertz) and tags (internal metadata) from an audio blob.
   #
   # Example:
   #
   #   ActiveStorage::Analyzer::AudioAnalyzer.new(blob).metadata
-  #   # => { duration: 5.0, bit_rate: 320340 }
+  #   # => { duration: 5.0, bit_rate: 320340, sample_rate: 44100, tags: { encoder: "Lavc57.64", ... } }
   #
-  # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by Rails.
+  # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by \Rails.
   class Analyzer::AudioAnalyzer < Analyzer
     def self.accept?(blob)
       blob.audio?
     end
 
     def metadata
-      { duration: duration, bit_rate: bit_rate }.compact
+      { duration: duration, bit_rate: bit_rate, sample_rate: sample_rate, tags: tags }.compact
     end
 
     private
@@ -29,6 +31,16 @@ module ActiveStorage
         Integer(bit_rate) if bit_rate
       end
 
+      def sample_rate
+        sample_rate = audio_stream["sample_rate"]
+        Integer(sample_rate) if sample_rate
+      end
+
+      def tags
+        tags = audio_stream["tags"]
+        Hash(tags) if tags
+      end
+
       def audio_stream
         @audio_stream ||= streams.detect { |stream| stream["codec_type"] == "audio" } || {}
       end

data/lib/active_storage/analyzer/image_analyzer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveStorage
+  # = Active Storage Image \Analyzer
+  #
   # 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.

data/lib/active_storage/analyzer/video_analyzer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveStorage
+  # = Active Storage Video \Analyzer
+  #
   # Extracts the following from a video blob:
   #
   # * Width (pixels)
@@ -18,7 +20,7 @@ module ActiveStorage
   #
   # When a video's angle is 90, -90, 270 or -270 degrees, its width and height are automatically swapped for convenience.
   #
-  # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by Rails.
+  # This analyzer requires the {FFmpeg}[https://www.ffmpeg.org] system library, which is not provided by \Rails.
   class Analyzer::VideoAnalyzer < Analyzer
     def self.accept?(blob)
       blob.video?

data/lib/active_storage/analyzer.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveStorage
+  # = Active Storage \Analyzer
+  #
   # This is an abstract base class for analyzers, which extract metadata from blobs. See
   # ActiveStorage::Analyzer::VideoAnalyzer for an example of a concrete subclass.
   class Analyzer

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

@@ -2,11 +2,12 @@
 
 module ActiveStorage
   class Attached::Changes::CreateMany # :nodoc:
-    attr_reader :name, :record, :attachables
+    attr_reader :name, :record, :attachables, :pending_uploads
 
-    def initialize(name, record, attachables)
+    def initialize(name, record, attachables, pending_uploads: [])
       @name, @record, @attachables = name, record, Array(attachables)
       blobs.each(&:identify_without_saving)
+      @pending_uploads = Array(pending_uploads) + subchanges_without_blobs
       attachments
     end
 
@@ -19,7 +20,7 @@ module ActiveStorage
     end
 
     def upload
-      subchanges.each(&:upload)
+      pending_uploads.each(&:upload)
     end
 
     def save
@@ -36,6 +37,10 @@ module ActiveStorage
         ActiveStorage::Attached::Changes::CreateOneOfMany.new(name, record, attachable)
       end
 
+      def subchanges_without_blobs
+        subchanges.reject { |subchange| subchange.attachable.is_a?(ActiveStorage::Blob) }
+      end
+
       def assign_associated_attachments
         record.public_send("#{name}_attachments=", persisted_or_new_attachments)
       end

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

@@ -22,10 +22,26 @@ module ActiveStorage
 
     def upload
       case attachable
-      when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
+      when ActionDispatch::Http::UploadedFile
         blob.upload_without_unfurling(attachable.open)
+      when Rack::Test::UploadedFile
+        blob.upload_without_unfurling(
+          attachable.respond_to?(:open) ? attachable.open : attachable
+        )
       when Hash
         blob.upload_without_unfurling(attachable.fetch(:io))
+      when File
+        blob.upload_without_unfurling(attachable)
+      when Pathname
+        blob.upload_without_unfurling(attachable.open)
+      when ActiveStorage::Blob
+      when String
+      else
+        raise(
+          ArgumentError,
+          "Could not upload: expected attachable, " \
+            "got #{attachable.inspect}"
+        )
       end
     end
 
@@ -53,7 +69,7 @@ module ActiveStorage
         case attachable
         when ActiveStorage::Blob
           attachable
-        when ActionDispatch::Http::UploadedFile, Rack::Test::UploadedFile
+        when ActionDispatch::Http::UploadedFile
           ActiveStorage::Blob.build_after_unfurling(
             io: attachable.open,
             filename: attachable.original_filename,
@@ -61,6 +77,14 @@ module ActiveStorage
             record: record,
             service_name: attachment_service_name
           )
+        when Rack::Test::UploadedFile
+          ActiveStorage::Blob.build_after_unfurling(
+            io: attachable.respond_to?(:open) ? attachable.open : attachable,
+            filename: attachable.original_filename,
+            content_type: attachable.content_type,
+            record: record,
+            service_name: attachment_service_name
+          )
         when Hash
           ActiveStorage::Blob.build_after_unfurling(
             **attachable.reverse_merge(
@@ -70,8 +94,26 @@ module ActiveStorage
           )
         when String
           ActiveStorage::Blob.find_signed!(attachable, record: record)
+        when File
+          ActiveStorage::Blob.build_after_unfurling(
+            io: attachable,
+            filename: File.basename(attachable),
+            record: record,
+            service_name: attachment_service_name
+          )
+        when Pathname
+          ActiveStorage::Blob.build_after_unfurling(
+            io: attachable.open,
+            filename: File.basename(attachable),
+            record: record,
+            service_name: attachment_service_name
+          )
         else
-          raise ArgumentError, "Could not find or build blob: expected attachable, got #{attachable.inspect}"
+          raise(
+            ArgumentError,
+            "Could not find or build blob: expected attachable, " \
+              "got #{attachable.inspect}"
+          )
         end
       end
 

data/lib/active_storage/attached/many.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveStorage
+  # = Active Storage \Attached \Many
+  #
   # Decorated proxy object representing of multiple attachments to a model.
   class Attached::Many < Attached
     ##
@@ -47,12 +49,11 @@ module ActiveStorage
     #   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)
+      record.public_send("#{name}=", blobs + attachables.flatten)
       if record.persisted? && !record.changed?
-        record.public_send("#{name}=", blobs + attachables.flatten)
-        record.save
-      else
-        record.public_send("#{name}=", (change&.attachables || blobs) + attachables.flatten)
+        return if !record.save
       end
+      record.public_send("#{name}")
     end
 
     # Returns true if any attachments have been made.

data/lib/active_storage/attached/model.rb

@@ -3,10 +3,54 @@
 require "active_support/core_ext/object/try"
 
 module ActiveStorage
+  # = Active Storage \Attached \Model
+  #
   # Provides the class-level DSL for declaring an Active Record model's attachments.
   module Attached::Model
     extend ActiveSupport::Concern
 
+    ##
+    # :method: *_attachment
+    #
+    # Returns the attachment for the +has_one_attached+.
+    #
+    #   User.last.avatar_attachment
+
+    ##
+    # :method: *_attachments
+    #
+    # Returns the attachments for the +has_many_attached+.
+    #
+    #   Gallery.last.photos_attachments
+
+    ##
+    # :method: *_blob
+    #
+    # Returns the blob for the +has_one_attached+ attachment.
+    #
+    #   User.last.avatar_blob
+
+    ##
+    # :method: *_blobs
+    #
+    # Returns the blobs for the +has_many_attached+ attachments.
+    #
+    #   Gallery.last.photos_blobs
+
+    ##
+    # :method: with_attached_*
+    #
+    # Includes the attached blobs in your query to avoid N+1 queries.
+    #
+    # If +ActiveStorage.track_variants+ is enabled, it will also include the
+    # variants record and their attached blobs.
+    #
+    #   User.with_attached_avatar
+    #
+    # Use the plural form for +has_many_attached+:
+    #
+    #   Gallery.with_attached_photos
+
     class_methods do
       # Specifies the relation between a single attachment and the model.
       #
@@ -59,7 +103,7 @@ module ActiveStorage
 
           def #{name}=(attachable)
             attachment_changes["#{name}"] =
-              if attachable.nil?
+              if attachable.nil? || attachable == ""
                 ActiveStorage::Attached::Changes::DeleteOne.new("#{name}", self)
               else
                 ActiveStorage::Attached::Changes::CreateOne.new("#{name}", self, attachable)
@@ -70,7 +114,13 @@ module ActiveStorage
         has_one :"#{name}_attachment", -> { where(name: name) }, class_name: "ActiveStorage::Attachment", as: :record, inverse_of: :record, dependent: :destroy, strict_loading: strict_loading
         has_one :"#{name}_blob", through: :"#{name}_attachment", class_name: "ActiveStorage::Blob", source: :blob, strict_loading: strict_loading
 
-        scope :"with_attached_#{name}", -> { includes("#{name}_attachment": :blob) }
+        scope :"with_attached_#{name}", -> {
+          if ActiveStorage.track_variants
+            includes("#{name}_attachment": { blob: { variant_records: { image_attachment: :blob } } })
+          else
+            includes("#{name}_attachment": :blob)
+          end
+        }
 
         after_save { attachment_changes[name.to_s]&.save }
 
@@ -138,57 +188,22 @@ module ActiveStorage
 
           def #{name}=(attachables)
             attachables = Array(attachables).compact_blank
+            pending_uploads = attachment_changes["#{name}"].try(:pending_uploads)
 
-            if ActiveStorage.replace_on_assign_to_many
-              attachment_changes["#{name}"] =
-                if attachables.none?
-                  ActiveStorage::Attached::Changes::DeleteMany.new("#{name}", self)
-                else
-                  ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, attachables)
-                end
+            attachment_changes["#{name}"] = if attachables.none?
+              ActiveStorage::Attached::Changes::DeleteMany.new("#{name}", self)
             else
-              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
+              ActiveStorage::Attached::Changes::CreateMany.new("#{name}", self, attachables, pending_uploads: pending_uploads)
             end
           end
         CODE
 
-        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}_attachments", -> { where(name: name) }, as: :record, class_name: "ActiveStorage::Attachment", inverse_of: :record, dependent: :destroy, strict_loading: strict_loading
         has_many :"#{name}_blobs", through: :"#{name}_attachments", class_name: "ActiveStorage::Blob", source: :blob, strict_loading: strict_loading
 
         scope :"with_attached_#{name}", -> {
           if ActiveStorage.track_variants
-            includes("#{name}_attachments": { blob: :variant_records })
+            includes("#{name}_attachments": { blob: { variant_records: { image_attachment: :blob } } })
           else
             includes("#{name}_attachments": :blob)
           end
@@ -215,6 +230,14 @@ module ActiveStorage
             ActiveStorage::Blob.services.fetch(service) do
               raise ArgumentError, "Cannot configure service :#{service} for #{name}##{association_name}"
             end
+          else
+            validate_global_service_configuration
+          end
+        end
+
+        def validate_global_service_configuration
+          if connected? && ActiveStorage::Blob.table_exists? && Rails.configuration.active_storage.service.nil?
+            raise RuntimeError, "Missing Active Storage service name. Specify Active Storage service name for config.active_storage.service in config/environments/#{Rails.env}.rb"
           end
         end
     end

data/lib/active_storage/attached/one.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 module ActiveStorage
+  # = Active Storage \Attached \One
+  #
   # Representation of a single attachment to a model.
   class Attached::One < Attached
     ##
@@ -54,12 +56,11 @@ module ActiveStorage
     #   person.avatar.attach(io: File.open("/path/to/face.jpg"), filename: "face.jpg", content_type: "image/jpeg")
     #   person.avatar.attach(avatar_blob) # ActiveStorage::Blob object
     def attach(attachable)
+      record.public_send("#{name}=", attachable)
       if record.persisted? && !record.changed?
-        record.public_send("#{name}=", attachable)
-        record.save
-      else
-        record.public_send("#{name}=", attachable)
+        return if !record.save
       end
+      record.public_send("#{name}")
     end
 
     # Returns +true+ if an attachment has been made.

data/lib/active_storage/attached.rb

@@ -3,6 +3,8 @@
 require "active_support/core_ext/module/delegation"
 
 module ActiveStorage
+  # = Active Storage \Attached
+  #
   # Abstract base class for the concrete ActiveStorage::Attached::One and ActiveStorage::Attached::Many
   # classes that both provide proxy access to the blob association for a record.
   class Attached

data/lib/active_storage/deprecator.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  def self.deprecator # :nodoc:
+    @deprecator ||= ActiveSupport::Deprecation.new
+  end
+end

data/lib/active_storage/engine.rb

@@ -35,9 +35,7 @@ module ActiveStorage
     config.active_storage.variable_content_types = %w(
       image/png
       image/gif
-      image/jpg
       image/jpeg
-      image/pjpeg
       image/tiff
       image/bmp
       image/vnd.adobe.photoshop
@@ -51,13 +49,11 @@ module ActiveStorage
     config.active_storage.web_image_content_types = %w(
       image/png
       image/jpeg
-      image/jpg
       image/gif
     )
 
     config.active_storage.content_types_to_serve_as_binary = %w(
       text/html
-      text/javascript
       image/svg+xml
       application/postscript
       application/x-shockwave-flash
@@ -71,7 +67,6 @@ module ActiveStorage
     config.active_storage.content_types_allowed_inline = %w(
       image/png
       image/gif
-      image/jpg
       image/jpeg
       image/tiff
       image/bmp
@@ -82,6 +77,10 @@ module ActiveStorage
 
     config.eager_load_namespaces << ActiveStorage
 
+    initializer "active_storage.deprecator", before: :load_environment_config do |app|
+      app.deprecators[:active_storage] = ActiveStorage.deprecator
+    end
+
     initializer "active_storage.configs" do
       config.after_initialize do |app|
         ActiveStorage.logger            = app.config.active_storage.logger || Rails.logger
@@ -117,9 +116,14 @@ module ActiveStorage
         ActiveStorage.binary_content_type = app.config.active_storage.binary_content_type || "application/octet-stream"
         ActiveStorage.video_preview_arguments = app.config.active_storage.video_preview_arguments || "-y -vframes 1 -f image2"
 
-        ActiveStorage.silence_invalid_content_types_warning = app.config.active_storage.silence_invalid_content_types_warning || false
+        unless app.config.active_storage.silence_invalid_content_types_warning.nil?
+          ActiveStorage.silence_invalid_content_types_warning = app.config.active_storage.silence_invalid_content_types_warning
+        end
+
+        unless app.config.active_storage.replace_on_assign_to_many.nil?
+          ActiveStorage.replace_on_assign_to_many = app.config.active_storage.replace_on_assign_to_many
+        end
 
-        ActiveStorage.replace_on_assign_to_many = app.config.active_storage.replace_on_assign_to_many || false
         ActiveStorage.track_variants = app.config.active_storage.track_variants || false
       end
     end

data/lib/active_storage/fixture_set.rb

@@ -4,6 +4,8 @@ require "active_support/testing/file_fixtures"
 require "active_record/secure_token"
 
 module ActiveStorage
+  # = Active Storage \FixtureSet
+  #
   # Fixtures are a way of organizing data that you want to test against; in
   # short, sample data.
   #