activestorage 5.2.7 → 6.0.0.beta1

data/app/models/active_storage/blob.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_storage/downloader"
+
 # 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:
 #
@@ -38,7 +40,7 @@ class ActiveStorage::Blob < ActiveRecord::Base
   end
 
   class << self
-    # You can used the signed ID of a blob to refer to it on the client side without fear of tampering.
+    # You can use the signed ID of a blob to refer to it on the client side without fear of tampering.
     # This is particularly helpful for direct uploads where the client-side needs to refer to the blob
     # that was created ahead of the upload itself on form submission.
     #
@@ -48,21 +50,25 @@ class ActiveStorage::Blob < ActiveRecord::Base
     end
 
     # Returns a new, unsaved blob instance after the +io+ has been uploaded to the service.
-    def build_after_upload(io:, filename:, content_type: nil, metadata: nil)
-      new.tap do |blob|
-        blob.filename     = filename
-        blob.content_type = content_type
-        blob.metadata     = metadata
+    # When providing a content type, pass <tt>identify: false</tt> to bypass automatic content type inference.
+    def build_after_upload(io:, filename:, content_type: nil, metadata: nil, identify: true)
+      new(filename: filename, content_type: content_type, metadata: metadata).tap do |blob|
+        blob.upload(io, identify: identify)
+      end
+    end
 
-        blob.upload io
+    def build_after_unfurling(io:, filename:, content_type: nil, metadata: nil, identify: true) #:nodoc:
+      new(filename: filename, content_type: content_type, metadata: metadata).tap do |blob|
+        blob.unfurl(io, identify: identify)
       end
     end
 
     # Returns a saved blob instance after the +io+ has been uploaded to the service. Note, the blob is first built,
     # then the +io+ is uploaded, then the blob is saved. This is done this way to avoid uploading (which may take
     # time), while having an open database transaction.
-    def create_after_upload!(io:, filename:, content_type: nil, metadata: nil)
-      build_after_upload(io: io, filename: filename, content_type: content_type, metadata: metadata).tap(&:save!)
+    # When providing a content type, pass <tt>identify: false</tt> to bypass automatic content type inference.
+    def create_after_upload!(io:, filename:, content_type: nil, metadata: nil, identify: true)
+      build_after_upload(io: io, filename: filename, content_type: content_type, metadata: metadata, identify: identify).tap(&:save!)
     end
 
     # Returns a saved blob _without_ uploading a file to the service. This blob will point to a key where there is
@@ -73,6 +79,15 @@ class ActiveStorage::Blob < ActiveRecord::Base
     def create_before_direct_upload!(filename:, byte_size:, checksum:, content_type: nil, metadata: nil)
       create! filename: filename, byte_size: byte_size, checksum: checksum, content_type: content_type, metadata: metadata
     end
+
+    # To prevent problems with case-insensitive filesystems, especially in combination
+    # with databases which treat indices as case-sensitive, all blob keys generated are going
+    # to only contain the base-36 character alphabet and will therefore be lowercase. To maintain
+    # the same or higher amount of entropy as in the base-58 encoding used by `has_secure_token`
+    # the number of bytes used is increased to 28 from the standard 24
+    def generate_unique_secure_token
+      SecureRandom.base36(28)
+    end
   end
 
   # Returns a signed ID for this blob that's suitable for reference on the client-side without fear of tampering.
@@ -81,9 +96,10 @@ class ActiveStorage::Blob < ActiveRecord::Base
     ActiveStorage.verifier.generate(id, purpose: :blob_id)
   end
 
-  # Returns the key pointing to the file on the service that's associated with this blob. The key is in the
-  # standard secure-token format from Rails. So it'll look like: XTAPjJCJiuDrLk3TmwyJGpUo. 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.
+  # 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.
+  # 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
     # We can't wait until the record is first saved to have a key for it
     self[:key] ||= self.class.generate_unique_secure_token
@@ -121,7 +137,7 @@ class ActiveStorage::Blob < ActiveRecord::Base
   # with users. Instead, the +service_url+ should only be exposed as a redirect from a stable, possibly authenticated URL.
   # Hiding the +service_url+ behind a redirect also gives you the power to change services without updating all URLs. And
   # it allows permanent URLs that redirect to the +service_url+ to be cached in the view.
-  def service_url(expires_in: service.url_expires_in, disposition: :inline, filename: nil, **options)
+  def service_url(expires_in: ActiveStorage.service_urls_expire_in, disposition: :inline, filename: nil, **options)
     filename = ActiveStorage::Filename.wrap(filename || self.filename)
 
     service.url key, expires_in: expires_in, filename: filename, content_type: content_type_for_service_url,
@@ -130,7 +146,7 @@ class ActiveStorage::Blob < ActiveRecord::Base
 
   # Returns a URL that can be used to directly upload a file for this blob on the service. This URL is intended to be
   # short-lived for security and only generated on-demand by the client-side JavaScript responsible for doing the uploading.
-  def service_url_for_direct_upload(expires_in: service.url_expires_in)
+  def service_url_for_direct_upload(expires_in: ActiveStorage.service_urls_expire_in)
     service.url_for_direct_upload key, expires_in: expires_in, content_type: content_type, content_length: byte_size, checksum: checksum
   end
 
@@ -146,16 +162,24 @@ class ActiveStorage::Blob < ActiveRecord::Base
   #
   # Prior to uploading, we compute the checksum, which is sent to the service for transit integrity validation. If the
   # checksum does not match what the service receives, an exception will be raised. We also measure the size of the +io+
-  # and store that in +byte_size+ on the blob record.
+  # and store that in +byte_size+ on the blob record. The content type is automatically extracted from the +io+ unless
+  # you specify a +content_type+ and pass +identify+ as false.
   #
   # Normally, you do not have to call this method directly at all. Use the factory class methods of +build_after_upload+
   # and +create_after_upload!+.
-  def upload(io)
+  def upload(io, identify: true)
+    unfurl io, identify: identify
+    upload_without_unfurling io
+  end
+
+  def unfurl(io, identify: true) #:nodoc:
     self.checksum     = compute_checksum_in_chunks(io)
-    self.content_type = extract_content_type(io)
+    self.content_type = extract_content_type(io) if content_type.nil? || identify
     self.byte_size    = io.size
     self.identified   = true
+  end
 
+  def upload_without_unfurling(io) #:nodoc:
     service.upload key, io, checksum: checksum, **service_metadata
   end
 
@@ -165,9 +189,26 @@ class ActiveStorage::Blob < ActiveRecord::Base
     service.download key, &block
   end
 
+  # Downloads the blob to a tempfile on disk. Yields the tempfile.
+  #
+  # The tempfile's name is prefixed with +ActiveStorage-+ and the blob's ID. Its extension matches that of the blob.
+  #
+  # By default, the tempfile is created in <tt>Dir.tmpdir</tt>. Pass +tempdir:+ to create it in a different directory:
+  #
+  #   blob.open(tempdir: "/path/to/tmp") do |file|
+  #     # ...
+  #   end
+  #
+  # The tempfile is automatically closed and unlinked after the given block is executed.
+  #
+  # Raises ActiveStorage::IntegrityError if the downloaded data does not match the blob's checksum.
+  def open(tempdir: nil, &block)
+    ActiveStorage::Downloader.new(self, tempdir: tempdir).download_blob_to_tempfile(&block)
+  end
+
 
-  # Deletes the file on the service that's associated with this blob. This should only be done if the blob is going to be
-  # deleted as well or you will essentially have a dead reference. It's recommended to use the +#purge+ and +#purge_later+
+  # Deletes the files on the service associated with the blob. This should only be done if the blob is going to be
+  # deleted as well or you will essentially have a dead reference. It's recommended to use #purge and #purge_later
   # methods in most circumstances.
   def delete
     service.delete(key)
@@ -176,15 +217,15 @@ class ActiveStorage::Blob < ActiveRecord::Base
 
   # Deletes the file on the service and then destroys the blob record. This is the recommended way to dispose of unwanted
   # blobs. Note, though, that deleting the file off the service will initiate a HTTP connection to the service, which may
-  # be slow or prevented, so you should not use this method inside a transaction or in callbacks. Use +#purge_later+ instead.
+  # be slow or prevented, so you should not use this method inside a transaction or in callbacks. Use #purge_later instead.
   def purge
     destroy
     delete
   rescue ActiveRecord::InvalidForeignKey
   end
 
-  # Enqueues an ActiveStorage::PurgeJob job that'll call +purge+. This is the recommended way to purge blobs when the call
-  # needs to be made from a transaction, a callback, or any other real-time scenario.
+  # Enqueues an ActiveStorage::PurgeJob to call #purge. This is the recommended way to purge blobs from a transaction,
+  # an Active Record callback, or in any other real-time scenario.
   def purge_later
     ActiveStorage::PurgeJob.perform_later(self)
   end

data/app/models/active_storage/filename.rb

@@ -3,8 +3,6 @@
 # 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
-  require_dependency "active_storage/filename/parameters"
-
   include Comparable
 
   class << self
@@ -60,10 +58,6 @@ class ActiveStorage::Filename
     @filename.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�").strip.tr("\u{202E}%$|:;/\t\r\n\\", "-")
   end
 
-  def parameters #:nodoc:
-    Parameters.new self
-  end
-
   # Returns the sanitized version of the filename.
   def to_s
     sanitized.to_s

data/app/models/active_storage/preview.rb

@@ -22,8 +22,8 @@
 # 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.
+# {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
 # install and use third-party software, make sure you understand the licensing implications of doing so.
@@ -38,7 +38,7 @@ class ActiveStorage::Preview
 
   # Processes the preview if it has not been processed yet. Returns the receiving Preview instance for convenience:
   #
-  #   blob.preview(resize: "100x100").processed.service_url
+  #   blob.preview(resize_to_fit: [100, 100]).processed.service_url
   #
   # Processing a preview generates an image from its blob and attaches the preview image to the blob. Because the preview
   # image is stored with the blob, it is only generated once.

data/app/models/active_storage/variant.rb

@@ -1,24 +1,33 @@
 # frozen_string_literal: true
 
-require "active_storage/downloading"
+require "ostruct"
 
 # 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.
 #
-# Variants rely on {MiniMagick}[https://github.com/minimagick/minimagick] for the actual transformations
-# of the file, so you must add <tt>gem "mini_magick"</tt> to your Gemfile if you wish to use variants.
+# Variants rely on {ImageProcessing}[https://github.com/janko-m/image_processing] gem for the actual transformations
+# of the file, so you must add <tt>gem "image_processing"</tt> to your Gemfile if you wish to use variants. By
+# default, images will be processed with {ImageMagick}[http://imagemagick.org] using the
+# {MiniMagick}[https://github.com/minimagick/minimagick] gem, but you can also switch to the
+# {libvips}[http://jcupitt.github.io/libvips/] processor operated by the {ruby-vips}[https://github.com/jcupitt/ruby-vips]
+# gem).
 #
-# Note that to create a variant it's necessary to download the entire blob file from the service and load it
-# into memory. The larger the image, the more memory is used. Because of this process, you also want to be
-# considerate about when the variant is actually processed. You shouldn't be processing variants inline in a
-# template, for example. Delay the processing to an on-demand controller, like the one provided in
+#   Rails.application.config.active_storage.variant_processor
+#   # => :mini_magick
+#
+#   Rails.application.config.active_storage.variant_processor = :vips
+#   # => :vips
+#
+# Note that to create a variant it's necessary to download the entire blob file from the service. Because of this process,
+# you also want to be considerate about when the variant is actually processed. You shouldn't be processing variants inline
+# in a template, for example. Delay the processing to an on-demand controller, like the one provided in
 # ActiveStorage::RepresentationsController.
 #
 # To refer to such a delayed on-demand variant, simply link to the variant through the resolved route provided
 # by Active Storage like so:
 #
-#   <%= image_tag Current.user.avatar.variant(resize: "100x100") %>
+#   <%= image_tag Current.user.avatar.variant(resize_to_fit: [100, 100]) %>
 #
 # This will create a URL for that specific blob with that specific variant, which the ActiveStorage::RepresentationsController
 # can then produce on-demand.
@@ -27,19 +36,24 @@ require "active_storage/downloading"
 # has already been processed and uploaded to the service, and, if so, just return that. Otherwise it will perform
 # the transformations, upload the variant to the service, and return itself again. Example:
 #
-#   avatar.variant(resize: "100x100").processed.service_url
+#   avatar.variant(resize_to_fit: [100, 100]).processed.service_url
 #
 # This will create and process a variant of the avatar blob that's constrained to a height and width of 100.
 # Then it'll upload said variant to the service according to a derivative key of the blob and the transformations.
 #
-# A list of all possible transformations is available at https://www.imagemagick.org/script/mogrify.php. You can
-# combine as many as you like freely:
+# You can combine any number of ImageMagick/libvips operations into a variant, as well as any macros provided by the
+# ImageProcessing gem (such as +resize_to_fit+):
+#
+#   avatar.variant(resize_to_fit: [800, 800], monochrome: true, rotate: "-90")
+#
+# Visit the following links for a list of available ImageProcessing commands and ImageMagick/libvips operations:
 #
-#   avatar.variant(resize: "100x100", monochrome: true, rotate: "-90")
+# * {ImageProcessing::MiniMagick}[https://github.com/janko-m/image_processing/blob/master/doc/minimagick.md#methods]
+# * {ImageMagick reference}[https://www.imagemagick.org/script/mogrify.php]
+# * {ImageProcessing::Vips}[https://github.com/janko-m/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::Downloading
-
-  WEB_IMAGE_CONTENT_TYPES = %w( image/png image/jpeg image/jpg image/gif )
+  WEB_IMAGE_CONTENT_TYPES = %w[ image/png image/jpeg image/jpg image/gif ]
 
   attr_reader :blob, :variation
   delegate :service, to: :blob
@@ -67,7 +81,7 @@ class ActiveStorage::Variant
   # Use <tt>url_for(variant)</tt> (or the implied form, like +link_to variant+ or +redirect_to variant+) 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 service_url(expires_in: service.url_expires_in, disposition: :inline)
+  def service_url(expires_in: ActiveStorage.service_urls_expire_in, disposition: :inline)
     service.url key, expires_in: expires_in, disposition: disposition, filename: filename, content_type: content_type
   end
 
@@ -82,51 +96,36 @@ class ActiveStorage::Variant
     end
 
     def process
-      open_image do |image|
-        transform image
-        format image
-        upload image
+      blob.open do |image|
+        transform(image) { |output| upload(output) }
       end
     end
 
-
-    def filename
-      if WEB_IMAGE_CONTENT_TYPES.include?(blob.content_type)
-        blob.filename
-      else
-        ActiveStorage::Filename.new("#{blob.filename.base}.png")
-      end
+    def transform(image, &block)
+      variation.transform(image, format: format, &block)
     end
 
-    def content_type
-      blob.content_type.presence_in(WEB_IMAGE_CONTENT_TYPES) || "image/png"
+    def upload(file)
+      service.upload(key, file)
     end
 
 
-    def open_image(&block)
-      image = download_image
-
-      begin
-        yield image
-      ensure
-        image.destroy!
-      end
-    end
-
-    def download_image
-      require "mini_magick"
-      MiniMagick::Image.create(blob.filename.extension_with_delimiter) { |file| download_blob_to(file) }
+    def specification
+      @specification ||=
+        if WEB_IMAGE_CONTENT_TYPES.include?(blob.content_type)
+          Specification.new \
+            filename: blob.filename,
+            content_type: blob.content_type,
+            format: nil
+        else
+          Specification.new \
+            filename: ActiveStorage::Filename.new("#{blob.filename.base}.png"),
+            content_type: "image/png",
+            format: "png"
+        end
     end
 
-    def transform(image)
-      variation.transform(image)
-    end
+    delegate :filename, :content_type, :format, to: :specification
 
-    def format(image)
-      image.format("PNG") unless WEB_IMAGE_CONTENT_TYPES.include?(blob.content_type)
-    end
-
-    def upload(image)
-      File.open(image.path, "r") { |file| service.upload(key, file) }
-    end
+    class Specification < OpenStruct; end
 end

data/app/models/active_storage/variation.rb

@@ -6,23 +6,12 @@
 # In case you do need to use this directly, it's instantiated using a hash of transformations where
 # the key is the command and the value is the arguments. Example:
 #
-#   ActiveStorage::Variation.new(resize: "100x100", monochrome: true, trim: true, rotate: "-90")
+#   ActiveStorage::Variation.new(resize_to_fit: [100, 100], monochrome: true, trim: true, rotate: "-90")
 #
-# You can also combine multiple transformations in one step, e.g. for center-weighted cropping:
-#
-#   ActiveStorage::Variation.new(combine_options: {
-#     resize: "100x100^",
-#     gravity: "center",
-#     crop: "100x100+0+0",
-#   })
-#
-# A list of all possible transformations is available at https://www.imagemagick.org/script/mogrify.php.
+# The options map directly to {ImageProcessing}[https://github.com/janko-m/image_processing] commands.
 class ActiveStorage::Variation
   attr_reader :transformations
 
-  class UnsupportedImageProcessingMethod < StandardError; end
-  class UnsupportedImageProcessingArgument < StandardError; end
-
   class << self
     # Returns a Variation instance based on the given variator. If the variator is a Variation, it is
     # returned unmodified. If it is a String, it is passed to ActiveStorage::Variation.decode. Otherwise,
@@ -54,24 +43,13 @@ class ActiveStorage::Variation
     @transformations = transformations
   end
 
-  # Accepts an open MiniMagick image instance, like what's returned by <tt>MiniMagick::Image.read(io)</tt>,
-  # and performs the +transformations+ against it. The transformed image instance is then returned.
-  def transform(image)
+  # Accepts a File object, performs the +transformations+ against it, and
+  # saves the transformed image into a temporary file. If +format+ is specified
+  # it will be the format of the result image, otherwise the result image
+  # retains the source format.
+  def transform(file, format: nil, &block)
     ActiveSupport::Notifications.instrument("transform.active_storage") do
-      transformations.each do |name, argument_or_subtransformations|
-        validate_transformation(name, argument_or_subtransformations)
-        image.mogrify do |command|
-          if name.to_s == "combine_options"
-            argument_or_subtransformations.each do |subtransformation_name, subtransformation_argument|
-              validate_transformation(subtransformation_name, subtransformation_argument)
-              pass_transform_argument(command, subtransformation_name, subtransformation_argument)
-            end
-          else
-            validate_transformation(name, argument_or_subtransformations)
-            pass_transform_argument(command, name, argument_or_subtransformations)
-          end
-        end
-      end
+      transformer.transform(file, format: format, &block)
     end
   end
 
@@ -81,69 +59,22 @@ class ActiveStorage::Variation
   end
 
   private
-    def pass_transform_argument(command, method, argument)
-      if eligible_argument?(argument)
-        command.public_send(method, argument)
-      else
-        command.public_send(method)
-      end
-    end
-
-    def eligible_argument?(argument)
-      argument.present? && argument != true
-    end
-
-    def validate_transformation(name, argument)
-      method_name = name.to_s.gsub("-","_")
-
-      unless ActiveStorage.supported_image_processing_methods.any? { |method| method_name == method }
-        raise UnsupportedImageProcessingMethod, <<~ERROR.squish
-          One or more of the provided transformation methods is not supported.
-        ERROR
-      end
-
-      if argument.present?
-        if argument.is_a?(String) || argument.is_a?(Symbol)
-          validate_arg_string(argument)
-        elsif argument.is_a?(Array)
-          validate_arg_array(argument)
-        elsif argument.is_a?(Hash)
-          validate_arg_hash(argument)
-        end
-      end
-    end
-
-    def validate_arg_string(argument)
-      if ActiveStorage.unsupported_image_processing_arguments.any? { |bad_arg| argument.to_s.downcase.include?(bad_arg) }; raise UnsupportedImageProcessingArgument end
-    end
-
-    def validate_arg_array(argument)
-      argument.each do |arg|
-        if arg.is_a?(Integer) || arg.is_a?(Float)
-          next
-        elsif arg.is_a?(String) || arg.is_a?(Symbol)
-          validate_arg_string(arg)
-        elsif arg.is_a?(Array)
-          validate_arg_array(arg)
-        elsif arg.is_a?(Hash)
-          validate_arg_hash(arg)
-        end
-      end
-    end
-
-    def validate_arg_hash(argument)
-      argument.each do |key, value|
-        validate_arg_string(key)
-
-        if value.is_a?(Integer) || value.is_a?(Float)
-          next
-        elsif value.is_a?(String) || value.is_a?(Symbol)
-          validate_arg_string(value)
-        elsif value.is_a?(Array)
-          validate_arg_array(value)
-        elsif value.is_a?(Hash)
-          validate_arg_hash(value)
+    def transformer
+      if ActiveStorage.variant_processor
+        begin
+          require "image_processing"
+        rescue LoadError
+          ActiveSupport::Deprecation.warn <<~WARNING
+            Generating image variants will require the image_processing gem in Rails 6.1.
+            Please add `gem 'image_processing', '~> 1.2'` to your Gemfile.
+          WARNING
+
+          ActiveStorage::Transformers::MiniMagickTransformer.new(transformations)
+        else
+          ActiveStorage::Transformers::ImageProcessingTransformer.new(transformations)
         end
+      else
+        ActiveStorage::Transformers::MiniMagickTransformer.new(transformations)
       end
     end
 end

data/config/routes.rb

@@ -1,17 +1,15 @@
 # frozen_string_literal: true
 
 Rails.application.routes.draw do
-  get "/rails/active_storage/blobs/:signed_id/*filename" => "active_storage/blobs#show", as: :rails_service_blob
-
-  direct :rails_blob do |blob, options|
-    route_for(:rails_service_blob, blob.signed_id, blob.filename, options)
-  end
-
-  resolve("ActiveStorage::Blob")       { |blob, options| route_for(:rails_blob, blob, options) }
-  resolve("ActiveStorage::Attachment") { |attachment, options| route_for(:rails_blob, attachment.blob, options) }
+  scope ActiveStorage.routes_prefix do
+    get "/blobs/:signed_id/*filename" => "active_storage/blobs#show", as: :rails_service_blob
 
+    get "/representations/:signed_blob_id/:variation_key/*filename" => "active_storage/representations#show", as: :rails_blob_representation
 
-  get "/rails/active_storage/representations/:signed_blob_id/:variation_key/*filename" => "active_storage/representations#show", as: :rails_blob_representation
+    get  "/disk/:encoded_key/*filename" => "active_storage/disk#show", as: :rails_disk_service
+    put  "/disk/:encoded_token" => "active_storage/disk#update", as: :update_rails_disk_service
+    post "/direct_uploads" => "active_storage/direct_uploads#create", as: :rails_direct_uploads
+  end
 
   direct :rails_representation do |representation, options|
     signed_blob_id = representation.blob.signed_id
@@ -25,7 +23,10 @@ Rails.application.routes.draw do
   resolve("ActiveStorage::Preview") { |preview, options| route_for(:rails_representation, preview, options) }
 
 
-  get  "/rails/active_storage/disk/:encoded_key/*filename" => "active_storage/disk#show", as: :rails_disk_service
-  put  "/rails/active_storage/disk/:encoded_token" => "active_storage/disk#update", as: :update_rails_disk_service
-  post "/rails/active_storage/direct_uploads" => "active_storage/direct_uploads#create", as: :rails_direct_uploads
+  direct :rails_blob do |blob, options|
+    route_for(:rails_service_blob, blob.signed_id, blob.filename, options)
+  end
+
+  resolve("ActiveStorage::Blob")       { |blob, options| route_for(:rails_blob, blob, options) }
+  resolve("ActiveStorage::Attachment") { |attachment, options| route_for(:rails_blob, attachment.blob, options) }
 end

data/db/update_migrate/20180723000244_add_foreign_key_constraint_to_active_storage_attachments_for_blob_id.rb

@@ -0,0 +1,7 @@
+class AddForeignKeyConstraintToActiveStorageAttachmentsForBlobId < ActiveRecord::Migration[6.0]
+  def up
+    unless foreign_key_exists?(:active_storage_attachments, column: :blob_id)
+      add_foreign_key :active_storage_attachments, :active_storage_blobs, column: :blob_id
+    end
+  end
+end

data/lib/active_storage/analyzer/video_analyzer.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/hash/compact"
-
 module ActiveStorage
   # Extracts the following from a video blob:
   #
@@ -18,7 +16,7 @@ module ActiveStorage
   #
   # When a video's angle is 90 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?
@@ -109,7 +107,7 @@ module ActiveStorage
           JSON.parse(output.read)
         end
       rescue Errno::ENOENT
-        logger.info "Skipping video analysis because ffmpeg isn't installed"
+        logger.info "Skipping video analysis because FFmpeg isn't installed"
         {}
       end
 

data/lib/active_storage/analyzer.rb

@@ -1,13 +1,9 @@
 # frozen_string_literal: true
 
-require "active_storage/downloading"
-
 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.
   class Analyzer
-    include Downloading
-
     attr_reader :blob
 
     # Implement this method in a concrete subclass. Have it return true when given a blob from which
@@ -26,8 +22,17 @@ module ActiveStorage
     end
 
     private
+      # Downloads the blob to a tempfile on disk. Yields the tempfile.
+      def download_blob_to_tempfile(&block) #:doc:
+        blob.open tempdir: tempdir, &block
+      end
+
       def logger #:doc:
         ActiveStorage.logger
       end
+
+      def tempdir #:doc:
+        Dir.tmpdir
+      end
   end
 end