activestorage 7.0.8.4 → 7.1.3.4

data/app/models/active_storage/blob.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# = Active Storage \Blob
+#
 # A blob is a record that contains the metadata about a file and a key for where that file resides on the service.
 # Blobs can be created in two ways:
 #
@@ -15,26 +17,10 @@
 # update a blob's metadata on a subsequent pass, but you should not update the key or change the uploaded file.
 # If you need to create a derivative or otherwise change the blob, simply create a new blob and purge the old one.
 class ActiveStorage::Blob < ActiveStorage::Record
-  # We use constant paths in the following include calls to avoid a gotcha of
-  # classic mode: If the parent application defines a top-level Analyzable, for
-  # example, and ActiveStorage::Blob::Analyzable is not yet loaded, a bare
-  #
-  #   include Analyzable
-  #
-  # would resolve to the top-level one, const_missing would not be triggered,
-  # and therefore ActiveStorage::Blob::Analyzable would not be autoloaded.
-  #
-  # By using qualified names, we ensure const_missing is invoked if needed.
-  # Please, note that Ruby 2.5 or newer is required, so Object is not checked
-  # when looking up the ancestors of ActiveStorage::Blob.
-  #
-  # Zeitwerk mode does not have this gotcha. If we ever drop classic mode, this
-  # can be simplified, bare constant names would just work.
-  include ActiveStorage::Blob::Analyzable
-  include ActiveStorage::Blob::Identifiable
-  include ActiveStorage::Blob::Representable
-
-  self.table_name = "active_storage_blobs"
+  include Analyzable
+  include Identifiable
+  include Representable
+  include Servable
 
   MINIMUM_TOKEN_LENGTH = 28
 
@@ -44,14 +30,24 @@ class ActiveStorage::Blob < ActiveStorage::Record
   class_attribute :services, default: {}
   class_attribute :service, instance_accessor: false
 
+  ##
+  # :method:
+  #
+  # Returns the associated ActiveStorage::Attachment instances.
   has_many :attachments
 
+  ##
+  # :singleton-method:
+  #
+  # Returns the blobs that aren't attached to any record.
   scope :unattached, -> { where.missing(:attachments) }
 
   after_initialize do
     self.service_name ||= self.class.service&.name
   end
 
+  after_update :touch_attachment_records
+
   after_update_commit :update_service_metadata, if: -> { content_type_previously_changed? || metadata_previously_changed? }
 
   before_destroy(prepend: true) do
@@ -141,7 +137,10 @@ class ActiveStorage::Blob < ActiveStorage::Record
 
     def scope_for_strict_loading # :nodoc:
       if strict_loading_by_default? && ActiveStorage.track_variants
-        includes(variant_records: { image_attachment: :blob }, preview_image_attachment: :blob)
+        includes(
+          variant_records: { image_attachment: :blob },
+          preview_image_attachment: { blob: { variant_records: { image_attachment: :blob } } }
+        )
       else
         all
       end
@@ -161,12 +160,12 @@ class ActiveStorage::Blob < ActiveStorage::Record
   end
 
   # Returns a signed ID for this blob that's suitable for reference on the client-side without fear of tampering.
-  def signed_id(purpose: :blob_id, expires_in: nil)
+  def signed_id(purpose: :blob_id, expires_in: nil, expires_at: nil)
     super
   end
 
   # Returns the key pointing to the file on the service that's associated with this blob. The key is the
-  # secure-token format from Rails in lower case. So it'll look like: xtapjjcjiudrlk3tmwyjgpuobabd.
+  # secure-token format from \Rails in lower case. So it'll look like: xtapjjcjiudrlk3tmwyjgpuobabd.
   # This key is not intended to be revealed directly to the user.
   # Always refer to blobs using the signed_id or a verified form of the key.
   def key
@@ -229,16 +228,6 @@ class ActiveStorage::Blob < ActiveStorage::Record
     service.headers_for_direct_upload key, filename: filename, content_type: content_type, content_length: byte_size, checksum: checksum, custom_metadata: custom_metadata
   end
 
-  def content_type_for_serving # :nodoc:
-    forcibly_serve_as_binary? ? ActiveStorage.binary_content_type : content_type
-  end
-
-  def forced_disposition_for_serving # :nodoc:
-    if forcibly_serve_as_binary? || !allowed_inline?
-      :attachment
-    end
-  end
-
 
   # Uploads the +io+ to the service on the +key+ for this blob. Blobs are intended to be immutable, so you shouldn't be
   # using this method after a file has already been uploaded to fit with a blob. If you want to create a derivative blob,
@@ -309,7 +298,7 @@ class ActiveStorage::Blob < ActiveStorage::Record
   end
 
   def mirror_later # :nodoc:
-    ActiveStorage::MirrorJob.perform_later(key, checksum: checksum) if service.respond_to?(:mirror)
+    service.mirror_later key, checksum: checksum if service.respond_to?(:mirror_later)
   end
 
   # Deletes the files on the service associated with the blob. This should only be done if the blob is going to be
@@ -340,33 +329,10 @@ class ActiveStorage::Blob < ActiveStorage::Record
     services.fetch(service_name)
   end
 
-  def content_type=(value)
-    unless ActiveStorage.silence_invalid_content_types_warning
-      if INVALID_VARIABLE_CONTENT_TYPES_DEPRECATED_IN_RAILS_7.include?(value)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          #{value} is not a valid content type, it should not be used when creating a blob, and support for it will be removed in Rails 7.1.
-          If you want to keep supporting this content type past Rails 7.1, add it to `config.active_storage.variable_content_types`.
-          Dismiss this warning by setting `config.active_storage.silence_invalid_content_types_warning = true`.
-        MSG
-      end
-
-      if INVALID_VARIABLE_CONTENT_TYPES_TO_SERVE_AS_BINARY_DEPRECATED_IN_RAILS_7.include?(value)
-        ActiveSupport::Deprecation.warn(<<-MSG.squish)
-          #{value} is not a valid content type, it should not be used when creating a blob, and support for it will be removed in Rails 7.1.
-          If you want to keep supporting this content type past Rails 7.1, add it to `config.active_storage.content_types_to_serve_as_binary`.
-          Dismiss this warning by setting `config.active_storage.silence_invalid_content_types_warning = true`.
-        MSG
-      end
-    end
-
-    super
-  end
-
-  INVALID_VARIABLE_CONTENT_TYPES_DEPRECATED_IN_RAILS_7 = ["image/jpg", "image/pjpeg", "image/bmp"]
-  INVALID_VARIABLE_CONTENT_TYPES_TO_SERVE_AS_BINARY_DEPRECATED_IN_RAILS_7 = ["text/javascript"]
-
   private
     def compute_checksum_in_chunks(io)
+      raise ArgumentError, "io must be rewindable" unless io.respond_to?(:rewind)
+
       OpenSSL::Digest::MD5.new.tap do |checksum|
         while chunk = io.read(5.megabytes)
           checksum << chunk
@@ -380,14 +346,6 @@ class ActiveStorage::Blob < ActiveStorage::Record
       Marcel::MimeType.for io, name: filename.to_s, declared_type: content_type
     end
 
-    def forcibly_serve_as_binary?
-      ActiveStorage.content_types_to_serve_as_binary.include?(content_type)
-    end
-
-    def allowed_inline?
-      ActiveStorage.content_types_allowed_inline.include?(content_type)
-    end
-
     def web_image?
       ActiveStorage.web_image_content_types.include?(content_type)
     end
@@ -402,6 +360,12 @@ class ActiveStorage::Blob < ActiveStorage::Record
       end
     end
 
+    def touch_attachment_records
+      attachments.includes(:record).each do |attachment|
+        attachment.touch
+      end
+    end
+
     def update_service_metadata
       service.update_metadata key, **service_metadata if service_metadata.any?
     end

data/app/models/active_storage/current.rb

@@ -2,14 +2,4 @@
 
 class ActiveStorage::Current < ActiveSupport::CurrentAttributes # :nodoc:
   attribute :url_options
-
-  def host=(host)
-    ActiveSupport::Deprecation.warn("ActiveStorage::Current.host= is deprecated, instead use ActiveStorage::Current.url_options=")
-    self.url_options = { host: host }
-  end
-
-  def host
-    ActiveSupport::Deprecation.warn("ActiveStorage::Current.host is deprecated, instead use ActiveStorage::Current.url_options")
-    self.url_options&.dig(:host)
-  end
 end

data/app/models/active_storage/filename.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# = Active Storage \Filename
+#
 # Encapsulates a string representing a filename to provide convenient access to parts of it and sanitization.
 # A Filename instance is returned by ActiveStorage::Blob#filename, and is comparable so it can be used for sorting.
 class ActiveStorage::Filename

data/app/models/active_storage/named_variant.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class ActiveStorage::NamedVariant # :nodoc:
+  attr_reader :transformations, :preprocessed
+
+  def initialize(transformations)
+    @preprocessed = transformations[:preprocessed]
+    @transformations = transformations.except(:preprocessed)
+  end
+
+  def preprocessed?(record)
+    case preprocessed
+    when Symbol
+      record.send(preprocessed)
+    when Proc
+      preprocessed.call(record)
+    else
+      preprocessed
+    end
+  end
+end

data/app/models/active_storage/preview.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+# = Active Storage \Preview
+#
 # Some non-image blobs can be previewed: that is, they can be presented as images. A video blob can be previewed by
 # extracting its first frame, and a PDF blob can be previewed by extracting its first page.
 #
@@ -10,7 +12,7 @@
 # documentation for more details on what's required of previewers.
 #
 # To choose the previewer for a blob, Active Storage calls +accept?+ on each registered previewer in order. It uses the
-# first previewer for which +accept?+ returns true when given the blob. In a Rails application, add or remove previewers
+# first previewer for which +accept?+ returns true when given the blob. In a \Rails application, add or remove previewers
 # by manipulating +Rails.application.config.active_storage.previewers+ in an initializer:
 #
 #   Rails.application.config.active_storage.previewers
@@ -20,24 +22,28 @@
 #   Rails.application.config.active_storage.previewers << DOCXPreviewer
 #   # => [ ActiveStorage::Previewer::PopplerPDFPreviewer, ActiveStorage::Previewer::MuPDFPreviewer, ActiveStorage::Previewer::VideoPreviewer, DOCXPreviewer ]
 #
-# Outside of a Rails application, modify +ActiveStorage.previewers+ instead.
+# Outside of a \Rails application, modify +ActiveStorage.previewers+ instead.
 #
 # The built-in previewers rely on third-party system libraries. Specifically, the built-in video previewer requires
 # {FFmpeg}[https://www.ffmpeg.org]. Two PDF previewers are provided: one requires {Poppler}[https://poppler.freedesktop.org],
 # and the other requires {muPDF}[https://mupdf.com] (version 1.8 or newer). To preview PDFs, install either Poppler or muPDF.
 #
-# These libraries are not provided by Rails. You must install them yourself to use the built-in previewers. Before you
+# These libraries are not provided by \Rails. You must install them yourself to use the built-in previewers. Before you
 # install and use third-party software, make sure you understand the licensing implications of doing so.
 class ActiveStorage::Preview
+  include ActiveStorage::Blob::Servable
+
   class UnprocessedError < StandardError; end
 
+  delegate :filename, :content_type, to: :variant
+
   attr_reader :blob, :variation
 
   def initialize(blob, variation_or_variation_key)
     @blob, @variation = blob, ActiveStorage::Variation.wrap(variation_or_variation_key)
   end
 
-  # Processes the preview if it has not been processed yet. Returns the receiving Preview instance for convenience:
+  # Processes the preview if it has not been processed yet. Returns the receiving +ActiveStorage::Preview+ instance for convenience:
   #
   #   blob.preview(resize_to_limit: [100, 100]).processed.url
   #
@@ -45,6 +51,7 @@ class ActiveStorage::Preview
   # image is stored with the blob, it is only generated once.
   def processed
     process unless processed?
+    variant.processed
     self
   end
 

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.
@@ -51,6 +53,8 @@
 # * {ImageProcessing::Vips}[https://github.com/janko/image_processing/blob/master/doc/vips.md#methods]
 # * {ruby-vips reference}[http://www.rubydoc.info/gems/ruby-vips/Vips/Image]
 class ActiveStorage::Variant
+  include ActiveStorage::Blob::Servable
+
   attr_reader :blob, :variation
   delegate :service, to: :blob
   delegate :content_type, to: :variation
@@ -72,7 +76,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 +93,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_record.rb

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 class ActiveStorage::VariantRecord < ActiveStorage::Record
-  self.table_name = "active_storage_variant_records"
-
   belongs_to :blob
   has_one_attached :image
 end

data/app/models/active_storage/variant_with_record.rb

@@ -1,35 +1,49 @@
 # 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
+  include ActiveStorage::Blob::Servable
+
   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