Merge branch 'master' into custom-discarded-job-handling

70 files changed, 1364 insertions, 187 deletions

diff --git a/activestorage/CHANGELOG.md b/activestorage/CHANGELOG.md
index 358552313f..c5171e7490 100644
--- a/activestorage/CHANGELOG.md
+++ b/activestorage/CHANGELOG.md
@@ -1,3 +1,12 @@
+## Rails 5.2.0.beta2 (November 28, 2017) ##
+
+*   Fix the gem adding the migrations files to the package.
+
+    *Yuji Yaginuma*
+
+
+## Rails 5.2.0.beta1 (November 27, 2017) ##
+
 *   Added to Rails.
 
     *DHH*
diff --git a/activestorage/README.md b/activestorage/README.md
index 17d98978bb..8af0409ec5 100644
--- a/activestorage/README.md
+++ b/activestorage/README.md
@@ -12,6 +12,10 @@ A key difference to how Active Storage works compared to other attachment soluti
 
 `Blob` models store attachment metadata (filename, content-type, etc.), and their identifier key in the storage service. Blob models do not store the actual binary data. They are intended to be immutable in spirit. One file, one blob. You can associate the same blob with multiple application models as well. And if you want to do transformations of a given `Blob`, the idea is that you'll simply create a new one, rather than attempt to mutate the existing one (though of course you can delete the previous version later if you don't need it).
 
+## Installation
+
+Run `rails active_storage:install` to copy over active_storage migrations.
+
 ## Examples
 
 One attachment:
@@ -24,7 +28,7 @@ class User < ApplicationRecord
 end
 
 # Attach an avatar to the user.
-user.avatar.attach(io: File.open("~/face.jpg"), filename: "avatar.jpg", content_type: "image/jpg")
+user.avatar.attach(io: File.open("/path/to/face.jpg"), filename: "face.jpg", content_type: "image/jpg")
 
 # Does the user have an avatar?
 user.avatar.attached? # => true
@@ -63,7 +67,7 @@ end
 ```
 
 ```erb
-<%= form_with model: @message do |form| %>
+<%= form_with model: @message, local: true do |form| %>
   <%= form.text_field :title, placeholder: "Title" %><br>
   <%= form.text_area :content %><br><br>
 
@@ -139,3 +143,17 @@ Active Storage, with its included JavaScript library, supports uploading directl
 ## License
 
 Active Storage is released under the [MIT License](https://opensource.org/licenses/MIT).
+
+ ## Support
+
+API documentation is at:
+
+* http://api.rubyonrails.org
+
+Bug reports for the Ruby on Rails project can be filed here:
+
+* https://github.com/rails/rails/issues
+
+Feature requests should be discussed on the rails-core mailing list here:
+
+* https://groups.google.com/forum/?fromgroups#!forum/rubyonrails-core
diff --git a/activestorage/Rakefile b/activestorage/Rakefile
index aa71a65f6e..2aa4d2a76f 100644
--- a/activestorage/Rakefile
+++ b/activestorage/Rakefile
@@ -11,4 +11,6 @@ Rake::TestTask.new do |test|
   test.warning = false
 end
 
+task :package
+
 task default: :test
diff --git a/activestorage/activestorage.gemspec b/activestorage/activestorage.gemspec
index 911e1a0469..7f7f1a26ac 100644
--- a/activestorage/activestorage.gemspec
+++ b/activestorage/activestorage.gemspec
@@ -17,7 +17,7 @@ Gem::Specification.new do |s|
   s.email    = "david@loudthinking.com"
   s.homepage = "http://rubyonrails.org"
 
-  s.files        = Dir["CHANGELOG.md", "MIT-LICENSE", "README.md", "lib/**/*", "app/**/*", "config/**/*"]
+  s.files        = Dir["CHANGELOG.md", "MIT-LICENSE", "README.md", "lib/**/*", "app/**/*", "config/**/*", "db/**/*"]
   s.require_path = "lib"
 
   s.metadata = {
diff --git a/activestorage/app/controllers/active_storage/blobs_controller.rb b/activestorage/app/controllers/active_storage/blobs_controller.rb
index 00aa8567c8..a17e3852f9 100644
--- a/activestorage/app/controllers/active_storage/blobs_controller.rb
+++ b/activestorage/app/controllers/active_storage/blobs_controller.rb
@@ -6,20 +6,11 @@
 # authenticated redirection controller.
 class ActiveStorage::BlobsController < ActionController::Base
   def show
-    if blob = find_signed_blob
-      expires_in 5.minutes # service_url defaults to 5 minutes
-      redirect_to blob.service_url(disposition: disposition_param)
+    if blob = ActiveStorage::Blob.find_signed(params[:signed_id])
+      expires_in ActiveStorage::Blob.service.url_expires_in
+      redirect_to blob.service_url(disposition: params[:disposition])
     else
       head :not_found
     end
   end
-
-  private
-    def find_signed_blob
-      ActiveStorage::Blob.find_signed(params[:signed_id])
-    end
-
-    def disposition_param
-      params[:disposition].presence_in(%w( inline attachment )) || "inline"
-    end
 end
diff --git a/activestorage/app/controllers/active_storage/disk_controller.rb b/activestorage/app/controllers/active_storage/disk_controller.rb
index 41e6d61bff..a7e10c0696 100644
--- a/activestorage/app/controllers/active_storage/disk_controller.rb
+++ b/activestorage/app/controllers/active_storage/disk_controller.rb
@@ -5,10 +5,12 @@
 # Always go through the BlobsController, or your own authenticated controller, rather than directly
 # to the service url.
 class ActiveStorage::DiskController < ActionController::Base
+  skip_forgery_protection if default_protect_from_forgery
+
   def show
     if key = decode_verified_key
       send_data disk_service.download(key),
-        disposition: disposition_param, content_type: params[:content_type]
+        disposition: params[:disposition], content_type: params[:content_type]
     else
       head :not_found
     end
@@ -38,10 +40,6 @@ class ActiveStorage::DiskController < ActionController::Base
       ActiveStorage.verifier.verified(params[:encoded_key], purpose: :blob_key)
     end
 
-    def disposition_param
-      params[:disposition].presence || "inline"
-    end
-
 
     def decode_verified_token
       ActiveStorage.verifier.verified(params[:encoded_token], purpose: :blob_token)
diff --git a/activestorage/app/controllers/active_storage/previews_controller.rb b/activestorage/app/controllers/active_storage/previews_controller.rb
new file mode 100644
index 0000000000..9e8cf27b6e
--- /dev/null
+++ b/activestorage/app/controllers/active_storage/previews_controller.rb
@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+class ActiveStorage::PreviewsController < ActionController::Base
+  def show
+    if blob = ActiveStorage::Blob.find_signed(params[:signed_blob_id])
+      expires_in ActiveStorage::Blob.service.url_expires_in
+      redirect_to ActiveStorage::Preview.new(blob, params[:variation_key]).processed.service_url(disposition: params[:disposition])
+    else
+      head :not_found
+    end
+  end
+end
diff --git a/activestorage/app/controllers/active_storage/variants_controller.rb b/activestorage/app/controllers/active_storage/variants_controller.rb
index 02e3010626..dc5e78ecc0 100644
--- a/activestorage/app/controllers/active_storage/variants_controller.rb
+++ b/activestorage/app/controllers/active_storage/variants_controller.rb
@@ -6,24 +6,11 @@
 # authenticated redirection controller.
 class ActiveStorage::VariantsController < ActionController::Base
   def show
-    if blob = find_signed_blob
-      expires_in 5.minutes # service_url defaults to 5 minutes
-      redirect_to ActiveStorage::Variant.new(blob, decoded_variation).processed.service_url(disposition: disposition_param)
+    if blob = ActiveStorage::Blob.find_signed(params[:signed_blob_id])
+      expires_in ActiveStorage::Blob.service.url_expires_in
+      redirect_to ActiveStorage::Variant.new(blob, params[:variation_key]).processed.service_url(disposition: params[:disposition])
     else
       head :not_found
     end
   end
-
-  private
-    def find_signed_blob
-      ActiveStorage::Blob.find_signed(params[:signed_blob_id])
-    end
-
-    def decoded_variation
-      ActiveStorage::Variation.decode(params[:variation_key])
-    end
-
-    def disposition_param
-      params[:disposition].presence_in(%w( inline attachment )) || "inline"
-    end
 end
diff --git a/activestorage/app/jobs/active_storage/analyze_job.rb b/activestorage/app/jobs/active_storage/analyze_job.rb
new file mode 100644
index 0000000000..2a952f9f74
--- /dev/null
+++ b/activestorage/app/jobs/active_storage/analyze_job.rb
@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# Provides asynchronous analysis of ActiveStorage::Blob records via ActiveStorage::Blob#analyze_later.
+class ActiveStorage::AnalyzeJob < ActiveStorage::BaseJob
+  def perform(blob)
+    blob.analyze
+  end
+end
diff --git a/activestorage/app/jobs/active_storage/base_job.rb b/activestorage/app/jobs/active_storage/base_job.rb
new file mode 100644
index 0000000000..6caab42a2d
--- /dev/null
+++ b/activestorage/app/jobs/active_storage/base_job.rb
@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+class ActiveStorage::BaseJob < ActiveJob::Base
+  queue_as { ActiveStorage.queue }
+end
diff --git a/activestorage/app/jobs/active_storage/purge_job.rb b/activestorage/app/jobs/active_storage/purge_job.rb
index 990ab27c9f..98874d2250 100644
--- a/activestorage/app/jobs/active_storage/purge_job.rb
+++ b/activestorage/app/jobs/active_storage/purge_job.rb
@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-# Provides delayed purging of ActiveStorage::Blob records via ActiveStorage::Blob#purge_later.
-class ActiveStorage::PurgeJob < ActiveJob::Base
+# Provides asynchronous purging of ActiveStorage::Blob records via ActiveStorage::Blob#purge_later.
+class ActiveStorage::PurgeJob < ActiveStorage::BaseJob
   # FIXME: Limit this to a custom ActiveStorage error
   retry_on StandardError
 
diff --git a/activestorage/app/models/active_storage/attachment.rb b/activestorage/app/models/active_storage/attachment.rb
index 29226e8ee9..9f61a5dbf3 100644
--- a/activestorage/app/models/active_storage/attachment.rb
+++ b/activestorage/app/models/active_storage/attachment.rb
@@ -14,6 +14,8 @@ class ActiveStorage::Attachment < ActiveRecord::Base
 
   delegate_missing_to :blob
 
+  after_create_commit :analyze_blob_later
+
   # Synchronously purges the blob (deletes it from the configured service) and destroys the attachment.
   def purge
     blob.purge
@@ -25,4 +27,9 @@ class ActiveStorage::Attachment < ActiveRecord::Base
     blob.purge_later
     destroy
   end
+
+  private
+    def analyze_blob_later
+      blob.analyze_later unless blob.analyzed?
+    end
 end
diff --git a/activestorage/app/models/active_storage/blob.rb b/activestorage/app/models/active_storage/blob.rb
index e6cf08ce83..acaf22fac1 100644
--- a/activestorage/app/models/active_storage/blob.rb
+++ b/activestorage/app/models/active_storage/blob.rb
@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "active_storage/analyzer/null_analyzer"
+
 # 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:
 #
@@ -14,13 +16,20 @@
 # 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 < ActiveRecord::Base
+  class UnpreviewableError < StandardError; end
+  class UnrepresentableError < StandardError; end
+
   self.table_name = "active_storage_blobs"
 
   has_secure_token :key
-  store :metadata, coder: JSON
+  store :metadata, accessors: [ :analyzed ], coder: JSON
 
   class_attribute :service
 
+  has_many :attachments
+
+  has_one_attached :preview_image
+
   class << self
     # You can used 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
@@ -101,24 +110,76 @@ class ActiveStorage::Blob < ActiveRecord::Base
     content_type.start_with?("text")
   end
 
-  # Returns an ActiveStorage::Variant instance with the set of +transformations+
-  # passed in. This is only relevant for image files, and it allows any image to
-  # be transformed for size, colors, and the like. Example:
+  # Returns an ActiveStorage::Variant instance with the set of +transformations+ provided. This is only relevant for image
+  # files, and it allows any image to be transformed for size, colors, and the like. Example:
   #
   #   avatar.variant(resize: "100x100").processed.service_url
   #
-  # This will create and process a variant of the avatar blob that's constrained to a height and width of 100.
+  # This will create and process a variant of the avatar blob that's constrained to a height and width of 100px.
   # Then it'll upload said variant to the service according to a derivative key of the blob and the transformations.
   #
   # Frequently, though, you don't actually want to transform the variant right away. But rather simply refer to a
   # specific variant that can be created by a controller on-demand. Like so:
   #
-  #   <%= image_tag url_for(Current.user.avatar.variant(resize: "100x100")) %>
+  #   <%= image_tag Current.user.avatar.variant(resize: "100x100") %>
   #
   # This will create a URL for that specific blob with that specific variant, which the ActiveStorage::VariantsController
   # can then produce on-demand.
   def variant(transformations)
-    ActiveStorage::Variant.new(self, ActiveStorage::Variation.new(transformations))
+    ActiveStorage::Variant.new(self, ActiveStorage::Variation.wrap(transformations))
+  end
+
+
+  # Returns an ActiveStorage::Preview instance with the set of +transformations+ provided. A preview is an image generated
+  # from a non-image blob. Active Storage comes with built-in previewers for videos and PDF documents. The video previewer
+  # extracts the first frame from a video and the PDF previewer extracts the first page from a PDF document.
+  #
+  #   blob.preview(resize: "100x100").processed.service_url
+  #
+  # Avoid processing previews synchronously in views. Instead, link to a controller action that processes them on demand.
+  # Active Storage provides one, but you may want to create your own (for example, if you need authentication). Here’s
+  # how to use the built-in version:
+  #
+  #   <%= image_tag video.preview(resize: "100x100") %>
+  #
+  # This method raises ActiveStorage::Blob::UnpreviewableError if no previewer accepts the receiving blob. To determine
+  # whether a blob is accepted by any previewer, call ActiveStorage::Blob#previewable?.
+  def preview(transformations)
+    if previewable?
+      ActiveStorage::Preview.new(self, ActiveStorage::Variation.wrap(transformations))
+    else
+      raise UnpreviewableError
+    end
+  end
+
+  # Returns true if any registered previewer accepts the blob. By default, this will return true for videos and PDF documents.
+  def previewable?
+    ActiveStorage.previewers.any? { |klass| klass.accept?(self) }
+  end
+
+
+  # Returns an ActiveStorage::Preview instance for a previewable blob or an ActiveStorage::Variant instance for an image blob.
+  #
+  #   blob.representation(resize: "100x100").processed.service_url
+  #
+  # Raises ActiveStorage::Blob::UnrepresentableError if the receiving blob is neither an image nor previewable. Call
+  # ActiveStorage::Blob#representable? to determine whether a blob is representable.
+  #
+  # See ActiveStorage::Blob#preview and ActiveStorage::Blob#variant for more information.
+  def representation(transformations)
+    case
+    when previewable?
+      preview transformations
+    when image?
+      variant transformations
+    else
+      raise UnrepresentableError
+    end
+  end
+
+  # Returns true if the blob is an image or is previewable.
+  def representable?
+    image? || previewable?
   end
 
 
@@ -126,13 +187,13 @@ 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: 5.minutes, disposition: :inline)
-    service.url key, expires_in: expires_in, disposition: "#{disposition}; #{filename.parameters}", filename: filename, content_type: content_type
+  def service_url(expires_in: service.url_expires_in, disposition: "inline")
+    service.url key, expires_in: expires_in, disposition: disposition, filename: filename, content_type: content_type
   end
 
   # 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: 5.minutes)
+  def service_url_for_direct_upload(expires_in: service.url_expires_in)
     service.url_for_direct_upload key, expires_in: expires_in, content_type: content_type, content_length: byte_size, checksum: checksum
   end
 
@@ -165,11 +226,52 @@ class ActiveStorage::Blob < ActiveRecord::Base
   end
 
 
+  # Extracts and stores metadata from the file associated with this blob using a relevant analyzer. Active Storage comes
+  # with built-in analyzers for images and videos. See ActiveStorage::Analyzer::ImageAnalyzer and
+  # ActiveStorage::Analyzer::VideoAnalyzer for information about the specific attributes they extract and the third-party
+  # libraries they require.
+  #
+  # To choose the analyzer for a blob, Active Storage calls +accept?+ on each registered analyzer in order. It uses the
+  # first analyzer for which +accept?+ returns true when given the blob. If no registered analyzer accepts the blob, no
+  # metadata is extracted from it.
+  #
+  # In a Rails application, add or remove analyzers by manipulating +Rails.application.config.active_storage.analyzers+
+  # in an initializer:
+  #
+  #   # Add a custom analyzer for Microsoft Office documents:
+  #   Rails.application.config.active_storage.analyzers.append DOCXAnalyzer
+  #
+  #   # Remove the built-in video analyzer:
+  #   Rails.application.config.active_storage.analyzers.delete ActiveStorage::Analyzer::VideoAnalyzer
+  #
+  # Outside of a Rails application, manipulate +ActiveStorage.analyzers+ instead.
+  #
+  # You won't ordinarily need to call this method from a Rails application. New blobs are automatically and asynchronously
+  # analyzed via #analyze_later when they're attached for the first time.
+  def analyze
+    update! metadata: metadata.merge(extract_metadata_via_analyzer)
+  end
+
+  # Enqueues an ActiveStorage::AnalyzeJob which calls #analyze.
+  #
+  # This method is automatically called for a blob when it's attached for the first time. You can call it to analyze a blob
+  # again (e.g. if you add a new analyzer or modify an existing one).
+  def analyze_later
+    ActiveStorage::AnalyzeJob.perform_later(self)
+  end
+
+  # Returns true if the blob has been analyzed.
+  def analyzed?
+    analyzed
+  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+
   # methods in most circumstances.
   def delete
-    service.delete key
+    service.delete(key)
+    service.delete_prefixed("variants/#{key}/") if image?
   end
 
   # Deletes the file on the service and then destroys the blob record. This is the recommended way to dispose of unwanted
@@ -196,4 +298,17 @@ class ActiveStorage::Blob < ActiveRecord::Base
         io.rewind
       end.base64digest
     end
+
+
+    def extract_metadata_via_analyzer
+      analyzer.metadata.merge(analyzed: true)
+    end
+
+    def analyzer
+      analyzer_class.new(self)
+    end
+
+    def analyzer_class
+      ActiveStorage.analyzers.detect { |klass| klass.accept?(self) } || ActiveStorage::Analyzer::NullAnalyzer
+    end
 end
diff --git a/activestorage/app/models/active_storage/filename.rb b/activestorage/app/models/active_storage/filename.rb
index dead6b6d33..79d55dc889 100644
--- a/activestorage/app/models/active_storage/filename.rb
+++ b/activestorage/app/models/active_storage/filename.rb
@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-# Encapsulates a string representing a filename to provide convenience access to parts of it and a sanitized version.
-# This is what's returned by ActiveStorage::Blob#filename. A Filename instance is comparable so it can be used for sorting.
+# 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
   include Comparable
 
@@ -9,23 +9,31 @@ class ActiveStorage::Filename
     @filename = filename
   end
 
-  # Returns the basename of the filename.
+  # Returns the part of the filename preceding any extension.
   #
   #   ActiveStorage::Filename.new("racecar.jpg").base # => "racecar"
+  #   ActiveStorage::Filename.new("racecar").base     # => "racecar"
+  #   ActiveStorage::Filename.new(".gitignore").base  # => ".gitignore"
   def base
     File.basename @filename, extension_with_delimiter
   end
 
-  # Returns the extension with delimiter of the filename.
+  # Returns the extension of the filename (i.e. the substring following the last dot, excluding a dot at the
+  # beginning) with the dot that precedes it. If the filename has no extension, an empty string is returned.
   #
   #   ActiveStorage::Filename.new("racecar.jpg").extension_with_delimiter # => ".jpg"
+  #   ActiveStorage::Filename.new("racecar").extension_with_delimiter     # => ""
+  #   ActiveStorage::Filename.new(".gitignore").extension_with_delimiter  # => ""
   def extension_with_delimiter
     File.extname @filename
   end
 
-  # Returns the extension without delimiter of the filename.
+  # Returns the extension of the filename (i.e. the substring following the last dot, excluding a dot at
+  # the beginning). If the filename has no extension, an empty string is returned.
   #
   #   ActiveStorage::Filename.new("racecar.jpg").extension_without_delimiter # => "jpg"
+  #   ActiveStorage::Filename.new("racecar").extension_without_delimiter     # => ""
+  #   ActiveStorage::Filename.new(".gitignore").extension_without_delimiter  # => ""
   def extension_without_delimiter
     extension_with_delimiter.from(1).to_s
   end
@@ -37,7 +45,7 @@ class ActiveStorage::Filename
   #   ActiveStorage::Filename.new("foo:bar.jpg").sanitized # => "foo-bar.jpg"
   #   ActiveStorage::Filename.new("foo/bar.jpg").sanitized # => "foo-bar.jpg"
   #
-  # ...and any other character unsafe for URLs or storage is converted or stripped.
+  # Characters considered unsafe for storage (e.g. \, $, and the RTL override character) are replaced with a dash.
   def sanitized
     @filename.encode(Encoding::UTF_8, invalid: :replace, undef: :replace, replace: "�").strip.tr("\u{202E}%$|:;/\t\r\n\\", "-")
   end
diff --git a/activestorage/app/models/active_storage/preview.rb b/activestorage/app/models/active_storage/preview.rb
new file mode 100644
index 0000000000..be5053edae
--- /dev/null
+++ b/activestorage/app/models/active_storage/preview.rb
@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+# 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.
+#
+# A previewer extracts a preview image from a blob. Active Storage provides previewers for videos and PDFs:
+# ActiveStorage::Previewer::VideoPreviewer and ActiveStorage::Previewer::PDFPreviewer. Build custom previewers by
+# subclassing ActiveStorage::Previewer and implementing the requisite methods. Consult the ActiveStorage::Previewer
+# 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
+# by manipulating +Rails.application.config.active_storage.previewers+ in an initializer:
+#
+#   Rails.application.config.active_storage.previewers
+#   # => [ ActiveStorage::Previewer::PDFPreviewer, ActiveStorage::Previewer::VideoPreviewer ]
+#
+#   # Add a custom previewer for Microsoft Office documents:
+#   Rails.application.config.active_storage.previewers << DOCXPreviewer
+#   # => [ ActiveStorage::Previewer::PDFPreviewer, ActiveStorage::Previewer::VideoPreviewer, DOCXPreviewer ]
+#
+# Outside of a Rails application, modify +ActiveStorage.previewers+ instead.
+#
+# The built-in previewers rely on third-party system libraries:
+#
+# * {ffmpeg}[https://www.ffmpeg.org]
+# * {mupdf}[https://mupdf.com]
+#
+# 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
+  class UnprocessedError < StandardError; end
+
+  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:
+  #
+  #   blob.preview(resize: "100x100").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.
+  def processed
+    process unless processed?
+    self
+  end
+
+  # Returns the blob's attached preview image.
+  def image
+    blob.preview_image
+  end
+
+  # Returns the URL of the preview's variant on the service. Raises ActiveStorage::Preview::UnprocessedError if the
+  # preview has not been processed yet.
+  #
+  # This method synchronously processes a variant of the preview image, so do not call it in views. Instead, generate
+  # a stable URL that redirects to the short-lived URL returned by this method.
+  def service_url(**options)
+    if processed?
+      variant.service_url(options)
+    else
+      raise UnprocessedError
+    end
+  end
+
+  private
+    def processed?
+      image.attached?
+    end
+
+    def process
+      previewer.preview { |attachable| image.attach(attachable) }
+    end
+
+    def variant
+      ActiveStorage::Variant.new(image, variation).processed
+    end
+
+
+    def previewer
+      previewer_class.new(blob)
+    end
+
+    def previewer_class
+      ActiveStorage.previewers.detect { |klass| klass.accept?(blob) }
+    end
+end
diff --git a/activestorage/app/models/active_storage/variant.rb b/activestorage/app/models/active_storage/variant.rb
index 02bf32b352..fa5aa69bd3 100644
--- a/activestorage/app/models/active_storage/variant.rb
+++ b/activestorage/app/models/active_storage/variant.rb
@@ -38,8 +38,8 @@ class ActiveStorage::Variant
   attr_reader :blob, :variation
   delegate :service, to: :blob
 
-  def initialize(blob, variation)
-    @blob, @variation = blob, variation
+  def initialize(blob, variation_or_variation_key)
+    @blob, @variation = blob, ActiveStorage::Variation.wrap(variation_or_variation_key)
   end
 
   # Returns the variant instance itself after it's been processed or an existing processing has been found on the service.
@@ -50,7 +50,7 @@ class ActiveStorage::Variant
 
   # Returns a combination key of the blob and the variation that together identifies a specific variant.
   def key
-    "variants/#{blob.key}/#{variation.key}"
+    "variants/#{blob.key}/#{Digest::SHA256.hexdigest(variation.key)}"
   end
 
   # Returns the URL of the variant on the service. This URL is intended to be short-lived for security and not used directly
@@ -61,10 +61,14 @@ 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::VariantsController, which in turn will use this +service_call+ method
   # for its redirection.
-  def service_url(expires_in: 5.minutes, disposition: :inline)
+  def service_url(expires_in: service.url_expires_in, disposition: :inline)
     service.url key, expires_in: expires_in, disposition: disposition, filename: blob.filename, content_type: blob.content_type
   end
 
+  # Returns the receiving variant. Allows ActiveStorage::Variant and ActiveStorage::Preview instances to be used interchangeably.
+  def image
+    self
+  end
 
   private
     def processed?
diff --git a/activestorage/app/models/active_storage/variation.rb b/activestorage/app/models/active_storage/variation.rb
index bf269e2a8f..13bad87cac 100644
--- a/activestorage/app/models/active_storage/variation.rb
+++ b/activestorage/app/models/active_storage/variation.rb
@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "active_support/core_ext/object/inclusion"
-
 # 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.
 #
@@ -15,7 +13,21 @@ class ActiveStorage::Variation
   attr_reader :transformations
 
   class << self
-    # Returns a variation instance with the transformations that were encoded by +encode+.
+    # 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,
+    # it is assumed to be a transformations Hash and is passed directly to the constructor.
+    def wrap(variator)
+      case variator
+      when self
+        variator
+      when String
+        decode variator
+      else
+        new variator
+      end
+    end
+
+    # Returns a Variation instance with the transformations that were encoded by +encode+.
     def decode(key)
       new ActiveStorage.verifier.verify(key, purpose: :variation)
     end
diff --git a/activestorage/config/routes.rb b/activestorage/config/routes.rb
index 168788475c..1eae21445a 100644
--- a/activestorage/config/routes.rb
+++ b/activestorage/config/routes.rb
@@ -1,30 +1,43 @@
 # 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
+  get "/rails/active_storage/blobs/:signed_id/*filename" => "active_storage/blobs#show", as: :rails_service_blob, internal: true
 
-  direct :rails_blob do |blob|
-    route_for(:rails_service_blob, blob.signed_id, blob.filename)
+  direct :rails_blob do |blob, options|
+    route_for(:rails_service_blob, blob.signed_id, blob.filename, options)
   end
 
-  resolve("ActiveStorage::Blob")       { |blob| route_for(:rails_blob, blob) }
-  resolve("ActiveStorage::Attachment") { |attachment| route_for(:rails_blob, attachment.blob) }
+  resolve("ActiveStorage::Blob")       { |blob, options| route_for(:rails_blob, blob) }
+  resolve("ActiveStorage::Attachment") { |attachment, options| route_for(:rails_blob, attachment.blob, options) }
 
 
-  get "/rails/active_storage/variants/:signed_blob_id/:variation_key/*filename" => "active_storage/variants#show", as: :rails_blob_variation
+  get "/rails/active_storage/variants/:signed_blob_id/:variation_key/*filename" => "active_storage/variants#show", as: :rails_blob_variation, internal: true
 
-  direct :rails_variant do |variant|
+  direct :rails_variant do |variant, options|
     signed_blob_id = variant.blob.signed_id
     variation_key  = variant.variation.key
     filename       = variant.blob.filename
 
-    route_for(:rails_blob_variation, signed_blob_id, variation_key, filename)
+    route_for(:rails_blob_variation, signed_blob_id, variation_key, filename, options)
   end
 
-  resolve("ActiveStorage::Variant") { |variant| route_for(:rails_variant, variant) }
+  resolve("ActiveStorage::Variant") { |variant, options| route_for(:rails_variant, variant, 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
+  get "/rails/active_storage/previews/:signed_blob_id/:variation_key/*filename" => "active_storage/previews#show", as: :rails_blob_preview, internal: true
+
+  direct :rails_preview do |preview, options|
+    signed_blob_id = preview.blob.signed_id
+    variation_key  = preview.variation.key
+    filename       = preview.blob.filename
+
+    route_for(:rails_blob_preview, signed_blob_id, variation_key, filename, options)
+  end
+
+  resolve("ActiveStorage::Preview") { |preview, options| route_for(:rails_preview, preview, options) }
+
+
+  get  "/rails/active_storage/disk/:encoded_key/*filename" => "active_storage/disk#show", as: :rails_disk_service, internal: true
+  put  "/rails/active_storage/disk/:encoded_token" => "active_storage/disk#update", as: :update_rails_disk_service, internal: true
+  post "/rails/active_storage/direct_uploads" => "active_storage/direct_uploads#create", as: :rails_direct_uploads, internal: true
 end
diff --git a/activestorage/lib/active_storage.rb b/activestorage/lib/active_storage.rb
index ccc1d4a163..d1ff6b7032 100644
--- a/activestorage/lib/active_storage.rb
+++ b/activestorage/lib/active_storage.rb
@@ -26,13 +26,19 @@
 require "active_record"
 require "active_support"
 require "active_support/rails"
-require_relative "active_storage/version"
+require "active_storage/version"
 
 module ActiveStorage
   extend ActiveSupport::Autoload
 
   autoload :Attached
   autoload :Service
+  autoload :Previewer
+  autoload :Analyzer
 
+  mattr_accessor :logger
   mattr_accessor :verifier
+  mattr_accessor :queue
+  mattr_accessor :previewers, default: []
+  mattr_accessor :analyzers, default: []
 end
diff --git a/activestorage/lib/active_storage/analyzer.rb b/activestorage/lib/active_storage/analyzer.rb
new file mode 100644
index 0000000000..837785a12b
--- /dev/null
+++ b/activestorage/lib/active_storage/analyzer.rb
@@ -0,0 +1,33 @@
+# 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
+    # the analyzer can extract metadata.
+    def self.accept?(blob)
+      false
+    end
+
+    def initialize(blob)
+      @blob = blob
+    end
+
+    # Override this method in a concrete subclass. Have it return a Hash of metadata.
+    def metadata
+      raise NotImplementedError
+    end
+
+    private
+      def logger
+        ActiveStorage.logger
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/analyzer/image_analyzer.rb b/activestorage/lib/active_storage/analyzer/image_analyzer.rb
new file mode 100644
index 0000000000..25e0251e6e
--- /dev/null
+++ b/activestorage/lib/active_storage/analyzer/image_analyzer.rb
@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  # Extracts width and height in pixels from an image blob.
+  #
+  # Example:
+  #
+  #   ActiveStorage::Analyzer::ImageAnalyzer.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. These libraries are not provided by Rails; you must
+  # install them yourself to use this analyzer.
+  class Analyzer::ImageAnalyzer < Analyzer
+    def self.accept?(blob)
+      blob.image?
+    end
+
+    def metadata
+      read_image do |image|
+        { width: image.width, height: image.height }
+      end
+    rescue LoadError
+      logger.info "Skipping image analysis because the mini_magick gem isn't installed"
+      {}
+    end
+
+    private
+      def read_image
+        download_blob_to_tempfile do |file|
+          require "mini_magick"
+          yield MiniMagick::Image.new(file.path)
+        end
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/analyzer/null_analyzer.rb b/activestorage/lib/active_storage/analyzer/null_analyzer.rb
new file mode 100644
index 0000000000..8ff7ce48e5
--- /dev/null
+++ b/activestorage/lib/active_storage/analyzer/null_analyzer.rb
@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Analyzer::NullAnalyzer < Analyzer # :nodoc:
+    def self.accept?(blob)
+      true
+    end
+
+    def metadata
+      {}
+    end
+  end
+end
diff --git a/activestorage/lib/active_storage/analyzer/video_analyzer.rb b/activestorage/lib/active_storage/analyzer/video_analyzer.rb
new file mode 100644
index 0000000000..1c144baa37
--- /dev/null
+++ b/activestorage/lib/active_storage/analyzer/video_analyzer.rb
@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/hash/compact"
+
+module ActiveStorage
+  # Extracts the following from a video blob:
+  #
+  # * Width (pixels)
+  # * Height (pixels)
+  # * Duration (seconds)
+  # * Angle (degrees)
+  # * Aspect ratio
+  #
+  # Example:
+  #
+  #   ActiveStorage::VideoAnalyzer.new(blob).metadata
+  #   # => { width: 640, height: 480, duration: 5.0, angle: 0, aspect_ratio: [4, 3] }
+  #
+  # This analyzer requires the {ffmpeg}[https://www.ffmpeg.org] system library, which is not provided by Rails. You must
+  # install ffmpeg yourself to use this analyzer.
+  class Analyzer::VideoAnalyzer < Analyzer
+    class_attribute :ffprobe_path, default: "ffprobe"
+
+    def self.accept?(blob)
+      blob.video?
+    end
+
+    def metadata
+      { width: width, height: height, duration: duration, angle: angle, aspect_ratio: aspect_ratio }.compact
+    end
+
+    private
+      def width
+        rotated? ? raw_height : raw_width
+      end
+
+      def height
+        rotated? ? raw_width : raw_height
+      end
+
+      def raw_width
+        Integer(video_stream["width"]) if video_stream["width"]
+      end
+
+      def raw_height
+        Integer(video_stream["height"]) if video_stream["height"]
+      end
+
+      def duration
+        Float(video_stream["duration"]) if video_stream["duration"]
+      end
+
+      def angle
+        Integer(tags["rotate"]) if tags["rotate"]
+      end
+
+      def aspect_ratio
+        if descriptor = video_stream["display_aspect_ratio"]
+          descriptor.split(":", 2).collect(&:to_i)
+        end
+      end
+
+      def rotated?
+        angle == 90 || angle == 270
+      end
+
+
+      def tags
+        @tags ||= video_stream["tags"] || {}
+      end
+
+      def video_stream
+        @video_stream ||= streams.detect { |stream| stream["codec_type"] == "video" } || {}
+      end
+
+      def streams
+        probe["streams"] || []
+      end
+
+      def probe
+        download_blob_to_tempfile { |file| probe_from(file) }
+      end
+
+      def probe_from(file)
+        IO.popen([ ffprobe_path, "-print_format", "json", "-show_streams", "-v", "error", file.path ]) do |output|
+          JSON.parse(output.read)
+        end
+      rescue Errno::ENOENT
+        logger.info "Skipping video analysis because ffmpeg isn't installed"
+        {}
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/attached/macros.rb b/activestorage/lib/active_storage/attached/macros.rb
index 35a081adc4..2b38a9b887 100644
--- a/activestorage/lib/active_storage/attached/macros.rb
+++ b/activestorage/lib/active_storage/attached/macros.rb
@@ -12,6 +12,10 @@ module ActiveStorage
     # There is no column defined on the model side, Active Storage takes
     # care of the mapping between your records and the attachment.
     #
+    # To avoid N+1 queries, you can include the attached blobs in your query like so:
+    #
+    #   User.with_attached_avatar
+    #
     # Under the covers, this relationship is implemented as a +has_one+ association to a
     # ActiveStorage::Attachment record and a +has_one-through+ association to a
     # ActiveStorage::Blob record. These associations are available as +avatar_attachment+
@@ -28,11 +32,17 @@ module ActiveStorage
         def #{name}
           @active_storage_attached_#{name} ||= ActiveStorage::Attached::One.new("#{name}", self, dependent: #{dependent == :purge_later ? ":purge_later" : "false"})
         end
+
+        def #{name}=(attachable)
+          #{name}.attach(attachable)
+        end
       CODE
 
       has_one :"#{name}_attachment", -> { where(name: name) }, class_name: "ActiveStorage::Attachment", as: :record
       has_one :"#{name}_blob", through: :"#{name}_attachment", class_name: "ActiveStorage::Blob", source: :blob
 
+      scope :"with_attached_#{name}", -> { includes("#{name}_attachment": :blob) }
+
       if dependent == :purge_later
         before_destroy { public_send(name).purge_later }
       end
@@ -67,6 +77,10 @@ module ActiveStorage
         def #{name}
           @active_storage_attached_#{name} ||= ActiveStorage::Attached::Many.new("#{name}", self, dependent: #{dependent == :purge_later ? ":purge_later" : "false"})
         end
+
+        def #{name}=(attachables)
+          #{name}.attach(attachables)
+        end
       CODE
 
       has_many :"#{name}_attachments", -> { where(name: name) }, as: :record, class_name: "ActiveStorage::Attachment"
diff --git a/activestorage/lib/active_storage/attached/many.rb b/activestorage/lib/active_storage/attached/many.rb
index 59b7d7d559..6eace65b79 100644
--- a/activestorage/lib/active_storage/attached/many.rb
+++ b/activestorage/lib/active_storage/attached/many.rb
@@ -13,15 +13,18 @@ module ActiveStorage
     end
 
     # Associates one or several attachments with the current record, saving them to the database.
-    # Examples:
     #
     #   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("~/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/jpg")
     #   document.images.attach([ first_blob, second_blob ])
     def attach(*attachables)
       attachables.flatten.collect do |attachable|
-        attachments.create!(name: name, blob: create_blob_from(attachable))
+        if record.new_record?
+          attachments.build(record: record, blob: create_blob_from(attachable))
+        else
+          attachments.create!(record: record, blob: create_blob_from(attachable))
+        end
       end
     end
 
@@ -36,6 +39,11 @@ module ActiveStorage
       attachments.any?
     end
 
+    # Deletes associated attachments without purging them, leaving their respective blobs in place.
+    def detach
+      attachments.destroy_all if attached?
+    end
+
     # Directly purges each associated attachment (i.e. destroys the blobs and
     # attachments and deletes the files on the service).
     def purge
diff --git a/activestorage/lib/active_storage/attached/one.rb b/activestorage/lib/active_storage/attached/one.rb
index ac90f32d95..0244232b2c 100644
--- a/activestorage/lib/active_storage/attached/one.rb
+++ b/activestorage/lib/active_storage/attached/one.rb
@@ -14,17 +14,16 @@ module ActiveStorage
     end
 
     # Associates a given attachment with the current record, saving it to the database.
-    # Examples:
     #
     #   person.avatar.attach(params[:avatar]) # ActionDispatch::Http::UploadedFile object
     #   person.avatar.attach(params[:signed_blob_id]) # Signed reference to blob from direct upload
-    #   person.avatar.attach(io: File.open("~/face.jpg"), filename: "face.jpg", content_type: "image/jpg")
+    #   person.avatar.attach(io: File.open("/path/to/face.jpg"), filename: "face.jpg", content_type: "image/jpg")
     #   person.avatar.attach(avatar_blob) # ActiveStorage::Blob object
     def attach(attachable)
       if attached? && dependent == :purge_later
         replace attachable
       else
-        write_attachment create_attachment_from(attachable)
+        write_attachment build_attachment_from(attachable)
       end
     end
 
@@ -39,6 +38,14 @@ module ActiveStorage
       attachment.present?
     end
 
+    # Deletes the attachment without purging it, leaving its blob in place.
+    def detach
+      if attached?
+        attachment.destroy
+        write_attachment nil
+      end
+    end
+
     # Directly purges the attachment (i.e. destroys the blob and
     # attachment and deletes the file on the service).
     def purge
@@ -59,14 +66,14 @@ module ActiveStorage
       def replace(attachable)
         blob.tap do
           transaction do
-            destroy
-            write_attachment create_attachment_from(attachable)
+            detach
+            write_attachment build_attachment_from(attachable)
           end
         end.purge_later
       end
 
-      def create_attachment_from(attachable)
-        ActiveStorage::Attachment.create!(record: record, name: name, blob: create_blob_from(attachable))
+      def build_attachment_from(attachable)
+        ActiveStorage::Attachment.new(record: record, name: name, blob: create_blob_from(attachable))
       end
 
       def write_attachment(attachment)
diff --git a/activestorage/lib/active_storage/downloading.rb b/activestorage/lib/active_storage/downloading.rb
new file mode 100644
index 0000000000..3dac6b116a
--- /dev/null
+++ b/activestorage/lib/active_storage/downloading.rb
@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  module Downloading
+    private
+      # Opens a new tempfile in #tempdir and copies blob data into it. Yields the tempfile.
+      def download_blob_to_tempfile # :doc:
+        Tempfile.open("ActiveStorage", tempdir) do |file|
+          download_blob_to file
+          yield file
+        end
+      end
+
+      # Efficiently downloads blob data into the given file.
+      def download_blob_to(file) # :doc:
+        file.binmode
+        blob.download { |chunk| file.write(chunk) }
+        file.rewind
+      end
+
+      # Returns the directory in which tempfiles should be opened. Defaults to +Dir.tmpdir+.
+      def tempdir # :doc:
+        Dir.tmpdir
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/engine.rb b/activestorage/lib/active_storage/engine.rb
index 590a36a30a..b870e6d4d6 100644
--- a/activestorage/lib/active_storage/engine.rb
+++ b/activestorage/lib/active_storage/engine.rb
@@ -3,19 +3,29 @@
 require "rails"
 require "active_storage"
 
+require "active_storage/previewer/pdf_previewer"
+require "active_storage/previewer/video_previewer"
+
+require "active_storage/analyzer/image_analyzer"
+require "active_storage/analyzer/video_analyzer"
+
 module ActiveStorage
   class Engine < Rails::Engine # :nodoc:
     isolate_namespace ActiveStorage
 
     config.active_storage = ActiveSupport::OrderedOptions.new
+    config.active_storage.previewers = [ ActiveStorage::Previewer::PDFPreviewer, ActiveStorage::Previewer::VideoPreviewer ]
+    config.active_storage.analyzers = [ ActiveStorage::Analyzer::ImageAnalyzer, ActiveStorage::Analyzer::VideoAnalyzer ]
+    config.active_storage.paths = ActiveSupport::OrderedOptions.new
 
     config.eager_load_namespaces << ActiveStorage
 
-    initializer "active_storage.logger" do
-      require "active_storage/service"
-
+    initializer "active_storage.configs" do
       config.after_initialize do |app|
-        ActiveStorage::Service.logger = app.config.active_storage.logger || Rails.logger
+        ActiveStorage.logger     = app.config.active_storage.logger || Rails.logger
+        ActiveStorage.queue      = app.config.active_storage.queue
+        ActiveStorage.previewers = app.config.active_storage.previewers || []
+        ActiveStorage.analyzers  = app.config.active_storage.analyzers || []
       end
     end
 
@@ -59,5 +69,21 @@ module ActiveStorage
         end
       end
     end
+
+    initializer "active_storage.paths" do
+      config.after_initialize do |app|
+        if ffprobe_path = app.config.active_storage.paths.ffprobe
+          ActiveStorage::Analyzer::VideoAnalyzer.ffprobe_path = ffprobe_path
+        end
+
+        if ffmpeg_path = app.config.active_storage.paths.ffmpeg
+          ActiveStorage::Previewer::VideoPreviewer.ffmpeg_path = ffmpeg_path
+        end
+
+        if mutool_path = app.config.active_storage.paths.mutool
+          ActiveStorage::Previewer::PDFPreviewer.mutool_path = mutool_path
+        end
+      end
+    end
   end
 end
diff --git a/activestorage/lib/active_storage/gem_version.rb b/activestorage/lib/active_storage/gem_version.rb
index e1d7b3493a..f048bb0b77 100644
--- a/activestorage/lib/active_storage/gem_version.rb
+++ b/activestorage/lib/active_storage/gem_version.rb
@@ -10,7 +10,7 @@ module ActiveStorage
     MAJOR = 5
     MINOR = 2
     TINY  = 0
-    PRE   = "alpha"
+    PRE   = "beta2"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end
diff --git a/activestorage/lib/active_storage/log_subscriber.rb b/activestorage/lib/active_storage/log_subscriber.rb
index 0d00a75c0e..a4e148c1a5 100644
--- a/activestorage/lib/active_storage/log_subscriber.rb
+++ b/activestorage/lib/active_storage/log_subscriber.rb
@@ -18,6 +18,10 @@ module ActiveStorage
       info event, color("Deleted file from key: #{key_in(event)}", RED)
     end
 
+    def service_delete_prefixed(event)
+      info event, color("Deleted files by key prefix: #{event.payload[:prefix]}", RED)
+    end
+
     def service_exist(event)
       debug event, color("Checked if file exists at key: #{key_in(event)} (#{event.payload[:exist] ? "yes" : "no"})", BLUE)
     end
@@ -27,7 +31,7 @@ module ActiveStorage
     end
 
     def logger
-      ActiveStorage::Service.logger
+      ActiveStorage.logger
     end
 
     private
diff --git a/activestorage/lib/active_storage/previewer.rb b/activestorage/lib/active_storage/previewer.rb
new file mode 100644
index 0000000000..3d485988e9
--- /dev/null
+++ b/activestorage/lib/active_storage/previewer.rb
@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require "active_storage/downloading"
+
+module ActiveStorage
+  # This is an abstract base class for previewers, which generate images from blobs. See
+  # ActiveStorage::Previewer::PDFPreviewer and ActiveStorage::Previewer::VideoPreviewer for examples of
+  # concrete subclasses.
+  class Previewer
+    include Downloading
+
+    attr_reader :blob
+
+    # Implement this method in a concrete subclass. Have it return true when given a blob from which
+    # the previewer can generate an image.
+    def self.accept?(blob)
+      false
+    end
+
+    def initialize(blob)
+      @blob = blob
+    end
+
+    # Override this method in a concrete subclass. Have it yield an attachable preview image (i.e.
+    # anything accepted by ActiveStorage::Attached::One#attach).
+    def preview
+      raise NotImplementedError
+    end
+
+    private
+      # Executes a system command, capturing its binary output in a tempfile. Yields the tempfile.
+      #
+      # Use this method to shell out to a system library (e.g. mupdf or ffmpeg) for preview image
+      # generation. The resulting tempfile can be used as the +:io+ value in an attachable Hash:
+      #
+      #   def preview
+      #     download_blob_to_tempfile do |input|
+      #       draw "my-drawing-command", input.path, "--format", "png", "-" do |output|
+      #         yield io: output, filename: "#{blob.filename.base}.png", content_type: "image/png"
+      #       end
+      #     end
+      #   end
+      #
+      # The output tempfile is opened in the directory returned by ActiveStorage::Downloading#tempdir.
+      def draw(*argv) # :doc:
+        Tempfile.open("ActiveStorage", tempdir) do |file|
+          capture(*argv, to: file)
+          yield file
+        end
+      end
+
+      def capture(*argv, to:)
+        to.binmode
+        IO.popen(argv) { |out| IO.copy_stream(out, to) }
+        to.rewind
+      end
+
+      def logger
+        ActiveStorage.logger
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/previewer/pdf_previewer.rb b/activestorage/lib/active_storage/previewer/pdf_previewer.rb
new file mode 100644
index 0000000000..b84aefcc9c
--- /dev/null
+++ b/activestorage/lib/active_storage/previewer/pdf_previewer.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Previewer::PDFPreviewer < Previewer
+    class_attribute :mutool_path, default: "mutool"
+
+    def self.accept?(blob)
+      blob.content_type == "application/pdf"
+    end
+
+    def preview
+      download_blob_to_tempfile do |input|
+        draw_first_page_from input do |output|
+          yield io: output, filename: "#{blob.filename.base}.png", content_type: "image/png"
+        end
+      end
+    end
+
+    private
+      def draw_first_page_from(file, &block)
+        draw mutool_path, "draw", "-F", "png", "-o", "-", file.path, "1", &block
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/previewer/video_previewer.rb b/activestorage/lib/active_storage/previewer/video_previewer.rb
new file mode 100644
index 0000000000..5d06e33f44
--- /dev/null
+++ b/activestorage/lib/active_storage/previewer/video_previewer.rb
@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module ActiveStorage
+  class Previewer::VideoPreviewer < Previewer
+    class_attribute :ffmpeg_path, default: "ffmpeg"
+
+    def self.accept?(blob)
+      blob.video?
+    end
+
+    def preview
+      download_blob_to_tempfile do |input|
+        draw_relevant_frame_from input do |output|
+          yield io: output, filename: "#{blob.filename.base}.png", content_type: "image/png"
+        end
+      end
+    end
+
+    private
+      def draw_relevant_frame_from(file, &block)
+        draw ffmpeg_path, "-i", file.path, "-y", "-vcodec", "png",
+          "-vf", "thumbnail", "-vframes", "1", "-f", "image2", "-", &block
+      end
+  end
+end
diff --git a/activestorage/lib/active_storage/service.rb b/activestorage/lib/active_storage/service.rb
index b80fdea1ab..c8f675db86 100644
--- a/activestorage/lib/active_storage/service.rb
+++ b/activestorage/lib/active_storage/service.rb
@@ -4,6 +4,7 @@ require "active_storage/log_subscriber"
 
 module ActiveStorage
   class IntegrityError < StandardError; end
+
   # Abstract class serving as an interface for concrete services.
   #
   # The available services are:
@@ -40,7 +41,7 @@ module ActiveStorage
     extend ActiveSupport::Autoload
     autoload :Configurator
 
-    class_attribute :logger
+    class_attribute :url_expires_in, default: 5.minutes
 
     class << self
       # Configure an Active Storage service by name from a set of configurations,
@@ -77,6 +78,11 @@ module ActiveStorage
       raise NotImplementedError
     end
 
+    # Delete files at keys starting with the +prefix+.
+    def delete_prefixed(prefix)
+      raise NotImplementedError
+    end
+
     # Return +true+ if a file exists at the +key+.
     def exist?(key)
       raise NotImplementedError
@@ -103,15 +109,19 @@ module ActiveStorage
     end
 
     private
-      def instrument(operation, key, payload = {}, &block)
+      def instrument(operation, payload = {}, &block)
         ActiveSupport::Notifications.instrument(
           "service_#{operation}.active_storage",
-          payload.merge(key: key, service: service_name), &block)
+          payload.merge(service: service_name), &block)
       end
 
       def service_name
         # ActiveStorage::Service::DiskService => Disk
         self.class.name.split("::").third.remove("Service")
       end
+
+      def content_disposition_with(type: "inline", filename:)
+        (type.to_s.presence_in(%w( attachment inline )) || "inline") + "; #{filename.parameters}"
+      end
   end
 end
diff --git a/activestorage/lib/active_storage/service/azure_storage_service.rb b/activestorage/lib/active_storage/service/azure_storage_service.rb
index 895cc9c2f1..19b09991b3 100644
--- a/activestorage/lib/active_storage/service/azure_storage_service.rb
+++ b/activestorage/lib/active_storage/service/azure_storage_service.rb
@@ -19,7 +19,7 @@ module ActiveStorage
     end
 
     def upload(key, io, checksum: nil)
-      instrument :upload, key, checksum: checksum do
+      instrument :upload, key: key, checksum: checksum do
         begin
           blobs.create_block_blob(container, key, io, content_md5: checksum)
         rescue Azure::Core::Http::HTTPError
@@ -28,13 +28,13 @@ module ActiveStorage
       end
     end
 
-    def download(key)
+    def download(key, &block)
       if block_given?
-        instrument :streaming_download, key do
+        instrument :streaming_download, key: key do
           stream(key, &block)
         end
       else
-        instrument :download, key do
+        instrument :download, key: key do
           _, io = blobs.get_blob(container, key)
           io.force_encoding(Encoding::BINARY)
         end
@@ -42,7 +42,7 @@ module ActiveStorage
     end
 
     def delete(key)
-      instrument :delete, key do
+      instrument :delete, key: key do
         begin
           blobs.delete_blob(container, key)
         rescue Azure::Core::Http::HTTPError
@@ -51,8 +51,24 @@ module ActiveStorage
       end
     end
 
+    def delete_prefixed(prefix)
+      instrument :delete_prefixed, prefix: prefix do
+        marker = nil
+
+        loop do
+          results = blobs.list_blobs(container, prefix: prefix, marker: marker)
+
+          results.each do |blob|
+            blobs.delete_blob(container, blob.name)
+          end
+
+          break unless marker = results.continuation_token.presence
+        end
+      end
+    end
+
     def exist?(key)
-      instrument :exist, key do |payload|
+      instrument :exist, key: key do |payload|
         answer = blob_for(key).present?
         payload[:exist] = answer
         answer
@@ -60,13 +76,13 @@ module ActiveStorage
     end
 
     def url(key, expires_in:, filename:, disposition:, content_type:)
-      instrument :url, key do |payload|
+      instrument :url, key: key do |payload|
         base_url = url_for(key)
         generated_url = signer.signed_uri(
           URI(base_url), false,
           permissions: "r",
           expiry: format_expiry(expires_in),
-          content_disposition: disposition,
+          content_disposition: content_disposition_with(type: disposition, filename: filename),
           content_type: content_type
         ).to_s
 
@@ -77,7 +93,7 @@ module ActiveStorage
     end
 
     def url_for_direct_upload(key, expires_in:, content_type:, content_length:, checksum:)
-      instrument :url, key do |payload|
+      instrument :url, key: key do |payload|
         base_url = url_for(key)
         generated_url = signer.signed_uri(URI(base_url), false, permissions: "rw",
           expiry: format_expiry(expires_in)).to_s
@@ -108,15 +124,15 @@ module ActiveStorage
       end
 
       # Reads the object for the given key in chunks, yielding each to the block.
-      def stream(key, options = {}, &block)
+      def stream(key)
         blob = blob_for(key)
 
         chunk_size = 5.megabytes
         offset = 0
 
         while offset < blob.properties[:content_length]
-          _, io = blobs.get_blob(container, key, start_range: offset, end_range: offset + chunk_size - 1)
-          yield io
+          _, chunk = blobs.get_blob(container, key, start_range: offset, end_range: offset + chunk_size - 1)
+          yield chunk.force_encoding(Encoding::BINARY)
           offset += chunk_size
         end
       end
diff --git a/activestorage/lib/active_storage/service/disk_service.rb b/activestorage/lib/active_storage/service/disk_service.rb
index f600753a08..a8728c5bc3 100644
--- a/activestorage/lib/active_storage/service/disk_service.rb
+++ b/activestorage/lib/active_storage/service/disk_service.rb
@@ -16,7 +16,7 @@ module ActiveStorage
     end
 
     def upload(key, io, checksum: nil)
-      instrument :upload, key, checksum: checksum do
+      instrument :upload, key: key, checksum: checksum do
         IO.copy_stream(io, make_path_for(key))
         ensure_integrity_of(key, checksum) if checksum
       end
@@ -24,7 +24,7 @@ module ActiveStorage
 
     def download(key)
       if block_given?
-        instrument :streaming_download, key do
+        instrument :streaming_download, key: key do
           File.open(path_for(key), "rb") do |file|
             while data = file.read(64.kilobytes)
               yield data
@@ -32,14 +32,14 @@ module ActiveStorage
           end
         end
       else
-        instrument :download, key do
+        instrument :download, key: key do
           File.binread path_for(key)
         end
       end
     end
 
     def delete(key)
-      instrument :delete, key do
+      instrument :delete, key: key do
         begin
           File.delete path_for(key)
         rescue Errno::ENOENT
@@ -48,8 +48,16 @@ module ActiveStorage
       end
     end
 
+    def delete_prefixed(prefix)
+      instrument :delete_prefixed, prefix: prefix do
+        Dir.glob(path_for("#{prefix}*")).each do |path|
+          FileUtils.rm_rf(path)
+        end
+      end
+    end
+
     def exist?(key)
-      instrument :exist, key do |payload|
+      instrument :exist, key: key do |payload|
         answer = File.exist? path_for(key)
         payload[:exist] = answer
         answer
@@ -57,16 +65,17 @@ module ActiveStorage
     end
 
     def url(key, expires_in:, filename:, disposition:, content_type:)
-      instrument :url, key do |payload|
+      instrument :url, key: key do |payload|
         verified_key_with_expiration = ActiveStorage.verifier.generate(key, expires_in: expires_in, purpose: :blob_key)
 
         generated_url =
           if defined?(Rails.application)
             Rails.application.routes.url_helpers.rails_disk_service_path \
               verified_key_with_expiration,
-              filename: filename, disposition: disposition, content_type: content_type
+              filename: filename, disposition: content_disposition_with(type: disposition, filename: filename), content_type: content_type
           else
-            "/rails/active_storage/disk/#{verified_key_with_expiration}/#{filename}?content_type=#{content_type}&disposition=#{disposition}"
+            "/rails/active_storage/disk/#{verified_key_with_expiration}/#{filename}?content_type=#{content_type}" \
+              "&disposition=#{content_disposition_with(type: disposition, filename: filename)}"
           end
 
         payload[:url] = generated_url
@@ -76,7 +85,7 @@ module ActiveStorage
     end
 
     def url_for_direct_upload(key, expires_in:, content_type:, content_length:, checksum:)
-      instrument :url, key do |payload|
+      instrument :url, key: key do |payload|
         verified_token_with_expiration = ActiveStorage.verifier.generate(
           {
             key: key,
diff --git a/activestorage/lib/active_storage/service/gcs_service.rb b/activestorage/lib/active_storage/service/gcs_service.rb
index 685dd61a0a..6f6f4105fe 100644
--- a/activestorage/lib/active_storage/service/gcs_service.rb
+++ b/activestorage/lib/active_storage/service/gcs_service.rb
@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+gem "google-cloud-storage", "~> 1.8"
+
 require "google/cloud/storage"
 require "active_support/core_ext/object/to_query"
 
@@ -7,34 +9,42 @@ module ActiveStorage
   # Wraps the Google Cloud Storage as an Active Storage service. See ActiveStorage::Service for the generic API
   # documentation that applies to all services.
   class Service::GCSService < Service
-    attr_reader :client, :bucket
-
-    def initialize(project:, keyfile:, bucket:, **options)
-      @client = Google::Cloud::Storage.new(project: project, keyfile: keyfile, **options)
-      @bucket = @client.bucket(bucket)
+    def initialize(**config)
+      @config = config
     end
 
     def upload(key, io, checksum: nil)
-      instrument :upload, key, checksum: checksum do
+      instrument :upload, key: key, checksum: checksum do
         begin
-          bucket.create_file(io, key, md5: checksum)
+          # The official GCS client library doesn't allow us to create a file with no Content-Type metadata.
+          # We need the file we create to have no Content-Type so we can control it via the response-content-type
+          # param in signed URLs. Workaround: let the GCS client create the file with an inferred
+          # Content-Type (usually "application/octet-stream") then clear it.
+          bucket.create_file(io, key, md5: checksum).update do |file|
+            file.content_type = nil
+          end
         rescue Google::Cloud::InvalidArgumentError
           raise ActiveStorage::IntegrityError
         end
       end
     end
 
-    # FIXME: Add streaming when given a block
+    # FIXME: Download in chunks when given a block.
     def download(key)
-      instrument :download, key do
+      instrument :download, key: key do
         io = file_for(key).download
         io.rewind
-        io.read
+
+        if block_given?
+          yield io.read
+        else
+          io.read
+        end
       end
     end
 
     def delete(key)
-      instrument :delete, key do
+      instrument :delete, key: key do
         begin
           file_for(key).delete
         rescue Google::Cloud::NotFoundError
@@ -43,8 +53,14 @@ module ActiveStorage
       end
     end
 
+    def delete_prefixed(prefix)
+      instrument :delete_prefixed, prefix: prefix do
+        bucket.files(prefix: prefix).all(&:delete)
+      end
+    end
+
     def exist?(key)
-      instrument :exist, key do |payload|
+      instrument :exist, key: key do |payload|
         answer = file_for(key).exists?
         payload[:exist] = answer
         answer
@@ -52,9 +68,9 @@ module ActiveStorage
     end
 
     def url(key, expires_in:, filename:, content_type:, disposition:)
-      instrument :url, key do |payload|
+      instrument :url, key: key do |payload|
         generated_url = file_for(key).signed_url expires: expires_in, query: {
-          "response-content-disposition" => disposition,
+          "response-content-disposition" => content_disposition_with(type: disposition, filename: filename),
           "response-content-type" => content_type
         }
 
@@ -65,7 +81,7 @@ module ActiveStorage
     end
 
     def url_for_direct_upload(key, expires_in:, content_type:, content_length:, checksum:)
-      instrument :url, key do |payload|
+      instrument :url, key: key do |payload|
         generated_url = bucket.signed_url key, method: "PUT", expires: expires_in,
           content_type: content_type, content_md5: checksum
 
@@ -80,8 +96,18 @@ module ActiveStorage
     end
 
     private
+      attr_reader :config
+
       def file_for(key)
         bucket.file(key, skip_lookup: true)
       end
+
+      def bucket
+        @bucket ||= client.bucket(config.fetch(:bucket))
+      end
+
+      def client
+        @client ||= Google::Cloud::Storage.new(config.except(:bucket))
+      end
   end
 end
diff --git a/activestorage/lib/active_storage/service/mirror_service.rb b/activestorage/lib/active_storage/service/mirror_service.rb
index 39e922f7ab..7eca8ce7f4 100644
--- a/activestorage/lib/active_storage/service/mirror_service.rb
+++ b/activestorage/lib/active_storage/service/mirror_service.rb
@@ -35,6 +35,11 @@ module ActiveStorage
       perform_across_services :delete, key
     end
 
+    # Delete files at keys starting with the +prefix+ on all services.
+    def delete_prefixed(prefix)
+      perform_across_services :delete_prefixed, prefix
+    end
+
     private
       def each_service(&block)
         [ primary, *mirrors ].each(&block)
diff --git a/activestorage/lib/active_storage/service/s3_service.rb b/activestorage/lib/active_storage/service/s3_service.rb
index e074269353..c95672f338 100644
--- a/activestorage/lib/active_storage/service/s3_service.rb
+++ b/activestorage/lib/active_storage/service/s3_service.rb
@@ -17,7 +17,7 @@ module ActiveStorage
     end
 
     def upload(key, io, checksum: nil)
-      instrument :upload, key, checksum: checksum do
+      instrument :upload, key: key, checksum: checksum do
         begin
           object_for(key).put(upload_options.merge(body: io, content_md5: checksum))
         rescue Aws::S3::Errors::BadDigest
@@ -26,26 +26,32 @@ module ActiveStorage
       end
     end
 
-    def download(key)
+    def download(key, &block)
       if block_given?
-        instrument :streaming_download, key do
+        instrument :streaming_download, key: key do
           stream(key, &block)
         end
       else
-        instrument :download, key do
+        instrument :download, key: key do
           object_for(key).get.body.read.force_encoding(Encoding::BINARY)
         end
       end
     end
 
     def delete(key)
-      instrument :delete, key do
+      instrument :delete, key: key do
         object_for(key).delete
       end
     end
 
+    def delete_prefixed(prefix)
+      instrument :delete_prefixed, prefix: prefix do
+        bucket.objects(prefix: prefix).batch_delete!
+      end
+    end
+
     def exist?(key)
-      instrument :exist, key do |payload|
+      instrument :exist, key: key do |payload|
         answer = object_for(key).exists?
         payload[:exist] = answer
         answer
@@ -53,9 +59,9 @@ module ActiveStorage
     end
 
     def url(key, expires_in:, filename:, disposition:, content_type:)
-      instrument :url, key do |payload|
+      instrument :url, key: key do |payload|
         generated_url = object_for(key).presigned_url :get, expires_in: expires_in.to_i,
-          response_content_disposition: disposition,
+          response_content_disposition: content_disposition_with(type: disposition, filename: filename),
           response_content_type: content_type
 
         payload[:url] = generated_url
@@ -65,7 +71,7 @@ module ActiveStorage
     end
 
     def url_for_direct_upload(key, expires_in:, content_type:, content_length:, checksum:)
-      instrument :url, key do |payload|
+      instrument :url, key: key do |payload|
         generated_url = object_for(key).presigned_url :put, expires_in: expires_in.to_i,
           content_type: content_type, content_length: content_length, content_md5: checksum
 
@@ -85,14 +91,14 @@ module ActiveStorage
       end
 
       # Reads the object for the given key in chunks, yielding each to the block.
-      def stream(key, options = {}, &block)
+      def stream(key)
         object = object_for(key)
 
         chunk_size = 5.megabytes
         offset = 0
 
         while offset < object.content_length
-          yield object.read(options.merge(range: "bytes=#{offset}-#{offset + chunk_size - 1}"))
+          yield object.get(range: "bytes=#{offset}-#{offset + chunk_size - 1}").body.read.force_encoding(Encoding::BINARY)
           offset += chunk_size
         end
       end
diff --git a/activestorage/package.json b/activestorage/package.json
index b481295a8d..621706000b 100644
--- a/activestorage/package.json
+++ b/activestorage/package.json
@@ -1,6 +1,6 @@
 {
   "name": "activestorage",
-  "version": "5.2.0.alpha",
+  "version": "5.2.0-beta2",
   "description": "Attach cloud and local files in Rails applications",
   "main": "app/assets/javascripts/activestorage.js",
   "files": [
diff --git a/activestorage/test/analyzer/image_analyzer_test.rb b/activestorage/test/analyzer/image_analyzer_test.rb
new file mode 100644
index 0000000000..9087072215
--- /dev/null
+++ b/activestorage/test/analyzer/image_analyzer_test.rb
@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+require "active_storage/analyzer/image_analyzer"
+
+class ActiveStorage::Analyzer::ImageAnalyzerTest < ActiveSupport::TestCase
+  test "analyzing an image" do
+    blob = create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg")
+    metadata = blob.tap(&:analyze).metadata
+
+    assert_equal 4104, metadata[:width]
+    assert_equal 2736, metadata[:height]
+  end
+end
diff --git a/activestorage/test/analyzer/video_analyzer_test.rb b/activestorage/test/analyzer/video_analyzer_test.rb
new file mode 100644
index 0000000000..b3b9c97fe4
--- /dev/null
+++ b/activestorage/test/analyzer/video_analyzer_test.rb
@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+require "active_storage/analyzer/video_analyzer"
+
+class ActiveStorage::Analyzer::VideoAnalyzerTest < ActiveSupport::TestCase
+  test "analyzing a video" do
+    blob = create_file_blob(filename: "video.mp4", content_type: "video/mp4")
+    metadata = blob.tap(&:analyze).metadata
+
+    assert_equal 640, metadata[:width]
+    assert_equal 480, metadata[:height]
+    assert_equal [4, 3], metadata[:aspect_ratio]
+    assert_equal 5.166648, metadata[:duration]
+    assert_not_includes metadata, :angle
+  end
+
+  test "analyzing a rotated video" do
+    blob = create_file_blob(filename: "rotated_video.mp4", content_type: "video/mp4")
+    metadata = blob.tap(&:analyze).metadata
+
+    assert_equal 480, metadata[:width]
+    assert_equal 640, metadata[:height]
+    assert_equal [4, 3], metadata[:aspect_ratio]
+    assert_equal 5.227975, metadata[:duration]
+    assert_equal 90, metadata[:angle]
+  end
+
+  test "analyzing a video without a video stream" do
+    blob = create_file_blob(filename: "video_without_video_stream.mp4", content_type: "video/mp4")
+    assert_equal({ "analyzed" => true }, blob.tap(&:analyze).metadata)
+  end
+end
diff --git a/activestorage/test/controllers/blobs_controller_test.rb b/activestorage/test/controllers/blobs_controller_test.rb
index c37b9c8a10..97177e64c2 100644
--- a/activestorage/test/controllers/blobs_controller_test.rb
+++ b/activestorage/test/controllers/blobs_controller_test.rb
@@ -5,7 +5,7 @@ require "database/setup"
 
 class ActiveStorage::BlobsControllerTest < ActionDispatch::IntegrationTest
   setup do
-    @blob = create_image_blob filename: "racecar.jpg"
+    @blob = create_file_blob filename: "racecar.jpg"
   end
 
   test "showing blob utilizes browser caching" do
diff --git a/activestorage/test/controllers/previews_controller_test.rb b/activestorage/test/controllers/previews_controller_test.rb
new file mode 100644
index 0000000000..c3151a710e
--- /dev/null
+++ b/activestorage/test/controllers/previews_controller_test.rb
@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::PreviewsControllerTest < ActionDispatch::IntegrationTest
+  setup do
+    @blob = create_file_blob filename: "report.pdf", content_type: "application/pdf"
+  end
+
+  test "showing preview inline" do
+    get rails_blob_preview_url(
+      filename: @blob.filename,
+      signed_blob_id: @blob.signed_id,
+      variation_key: ActiveStorage::Variation.encode(resize: "100x100"))
+
+    assert @blob.preview_image.attached?
+    assert_redirected_to(/report\.png\?.*disposition=inline/)
+
+    image = read_image(@blob.preview_image.variant(resize: "100x100"))
+    assert_equal 77, image.width
+    assert_equal 100, image.height
+  end
+end
diff --git a/activestorage/test/controllers/variants_controller_test.rb b/activestorage/test/controllers/variants_controller_test.rb
index 0a049f3bc4..6c70d73786 100644
--- a/activestorage/test/controllers/variants_controller_test.rb
+++ b/activestorage/test/controllers/variants_controller_test.rb
@@ -5,7 +5,7 @@ require "database/setup"
 
 class ActiveStorage::VariantsControllerTest < ActionDispatch::IntegrationTest
   setup do
-    @blob = create_image_blob filename: "racecar.jpg"
+    @blob = create_file_blob filename: "racecar.jpg"
   end
 
   test "showing variant inline" do
@@ -16,7 +16,7 @@ class ActiveStorage::VariantsControllerTest < ActionDispatch::IntegrationTest
 
     assert_redirected_to(/racecar\.jpg\?.*disposition=inline/)
 
-    image = read_image_variant(@blob.variant(resize: "100x100"))
+    image = read_image(@blob.variant(resize: "100x100"))
     assert_equal 100, image.width
     assert_equal 67, image.height
   end
diff --git a/activestorage/test/database/setup.rb b/activestorage/test/database/setup.rb
index 87564499e6..705650a25d 100644
--- a/activestorage/test/database/setup.rb
+++ b/activestorage/test/database/setup.rb
@@ -3,5 +3,5 @@
 require_relative "create_users_migration"
 
 ActiveRecord::Base.establish_connection(adapter: "sqlite3", database: ":memory:")
-ActiveRecord::Migrator.migrate File.expand_path("../../../db/migrate", __FILE__)
+ActiveRecord::Migrator.migrate File.expand_path("../../db/migrate", __dir__)
 ActiveStorageCreateUsers.migrate(:up)
diff --git a/activestorage/test/dummy/bin/bundle b/activestorage/test/dummy/bin/bundle
index 277e128251..5015ba6f8b 100755
--- a/activestorage/test/dummy/bin/bundle
+++ b/activestorage/test/dummy/bin/bundle
@@ -1,5 +1,5 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../../Gemfile", __FILE__)
+ENV["BUNDLE_GEMFILE"] ||= File.expand_path("../Gemfile", __dir__)
 load Gem.bin_path("bundler", "bundle")
diff --git a/activestorage/test/dummy/config/application.rb b/activestorage/test/dummy/config/application.rb
index 7ee6625bb5..06cbc453a2 100644
--- a/activestorage/test/dummy/config/application.rb
+++ b/activestorage/test/dummy/config/application.rb
@@ -19,7 +19,7 @@ Bundler.require(*Rails.groups)
 
 module Dummy
   class Application < Rails::Application
-    config.load_defaults 5.1
+    config.load_defaults 5.2
 
     config.active_storage.service = :local
   end
diff --git a/activestorage/test/dummy/config/environments/test.rb b/activestorage/test/dummy/config/environments/test.rb
index ce0889e8ae..74a802d98c 100644
--- a/activestorage/test/dummy/config/environments/test.rb
+++ b/activestorage/test/dummy/config/environments/test.rb
@@ -30,6 +30,9 @@ Rails.application.configure do
   # Print deprecation notices to the stderr.
   config.active_support.deprecation = :stderr
 
+  # Disable request forgery protection in test environment.
+  config.action_controller.allow_forgery_protection = false
+
   # Raises error for missing translations
   # config.action_view.raise_on_missing_translations = true
 end
diff --git a/activestorage/test/fixtures/files/report.pdf b/activestorage/test/fixtures/files/report.pdf
new file mode 100644
index 0000000000..cccb9b5d64
--- /dev/null
+++ b/activestorage/test/fixtures/files/report.pdf
diff --git a/activestorage/test/fixtures/files/rotated_video.mp4 b/activestorage/test/fixtures/files/rotated_video.mp4
new file mode 100644
index 0000000000..4c7a4e9e57
--- /dev/null
+++ b/activestorage/test/fixtures/files/rotated_video.mp4
diff --git a/activestorage/test/fixtures/files/video.mp4 b/activestorage/test/fixtures/files/video.mp4
new file mode 100644
index 0000000000..8fb1c5b24d
--- /dev/null
+++ b/activestorage/test/fixtures/files/video.mp4
diff --git a/activestorage/test/fixtures/files/video_without_video_stream.mp4 b/activestorage/test/fixtures/files/video_without_video_stream.mp4
new file mode 100644
index 0000000000..e6a55f868b
--- /dev/null
+++ b/activestorage/test/fixtures/files/video_without_video_stream.mp4
diff --git a/activestorage/test/models/attachments_test.rb b/activestorage/test/models/attachments_test.rb
index ac346c0087..20eec3c220 100644
--- a/activestorage/test/models/attachments_test.rb
+++ b/activestorage/test/models/attachments_test.rb
@@ -15,7 +15,7 @@ class ActiveStorage::AttachmentsTest < ActiveSupport::TestCase
     assert_equal "funky.jpg", @user.avatar.filename.to_s
   end
 
-  test "attach existing sgid blob" do
+  test "attach existing blob from a signed ID" do
     @user.avatar.attach create_blob(filename: "funky.jpg").signed_id
     assert_equal "funky.jpg", @user.avatar.filename.to_s
   end
@@ -27,7 +27,7 @@ class ActiveStorage::AttachmentsTest < ActiveSupport::TestCase
 
   test "attach new blob from an UploadedFile" do
     file = file_fixture "racecar.jpg"
-    @user.avatar.attach Rack::Test::UploadedFile.new file
+    @user.avatar.attach Rack::Test::UploadedFile.new file.to_s
     assert_equal "racecar.jpg", @user.avatar.filename.to_s
   end
 
@@ -56,6 +56,40 @@ class ActiveStorage::AttachmentsTest < ActiveSupport::TestCase
     assert ActiveStorage::Blob.service.exist?(@user.avatar.key)
   end
 
+  test "attach blob to new record" do
+    user = User.new(name: "Jason")
+
+    assert_no_changes -> { user.new_record? } do
+      assert_no_difference -> { ActiveStorage::Attachment.count } do
+        user.avatar.attach create_blob(filename: "funky.jpg")
+      end
+    end
+
+    assert user.avatar.attached?
+    assert_equal "funky.jpg", user.avatar.filename.to_s
+
+    assert_difference -> { ActiveStorage::Attachment.count }, +1 do
+      user.save!
+    end
+
+    assert user.reload.avatar.attached?
+    assert_equal "funky.jpg", user.avatar.filename.to_s
+  end
+
+  test "build new record with attached blob" do
+    assert_no_difference -> { ActiveStorage::Attachment.count } do
+      @user = User.new(name: "Jason", avatar: { io: StringIO.new("STUFF"), filename: "town.jpg", content_type: "image/jpg" })
+    end
+
+    assert @user.new_record?
+    assert @user.avatar.attached?
+    assert_equal "town.jpg", @user.avatar.filename.to_s
+
+    @user.save!
+    assert @user.reload.avatar.attached?
+    assert_equal "town.jpg", @user.avatar.filename.to_s
+  end
+
   test "access underlying associations of new blob" do
     @user.avatar.attach create_blob(filename: "funky.jpg")
     assert_equal @user, @user.avatar_attachment.record
@@ -63,6 +97,52 @@ class ActiveStorage::AttachmentsTest < ActiveSupport::TestCase
     assert_equal "funky.jpg", @user.avatar_attachment.blob.filename.to_s
   end
 
+  test "analyze newly-attached blob" do
+    perform_enqueued_jobs do
+      @user.avatar.attach create_file_blob
+    end
+
+    assert_equal 4104, @user.avatar.reload.metadata[:width]
+    assert_equal 2736, @user.avatar.metadata[:height]
+  end
+
+  test "analyze attached blob only once" do
+    blob = create_file_blob
+
+    perform_enqueued_jobs do
+      @user.avatar.attach blob
+    end
+
+    assert blob.reload.analyzed?
+
+    @user.avatar.attachment.destroy
+
+    assert_no_enqueued_jobs do
+      @user.reload.avatar.attach blob
+    end
+  end
+
+  test "preserve existing metadata when analyzing a newly-attached blob" do
+    blob = create_file_blob(metadata: { foo: "bar" })
+
+    perform_enqueued_jobs do
+      @user.avatar.attach blob
+    end
+
+    assert_equal "bar", blob.reload.metadata[:foo]
+  end
+
+  test "detach blob" do
+    @user.avatar.attach create_blob(filename: "funky.jpg")
+    avatar_blob_id = @user.avatar.blob.id
+    avatar_key = @user.avatar.key
+
+    @user.avatar.detach
+    assert_not @user.avatar.attached?
+    assert ActiveStorage::Blob.exists?(avatar_blob_id)
+    assert ActiveStorage::Blob.service.exist?(avatar_key)
+  end
+
   test "purge attached blob" do
     @user.avatar.attach create_blob(filename: "funky.jpg")
     avatar_key = @user.avatar.key
@@ -84,6 +164,19 @@ class ActiveStorage::AttachmentsTest < ActiveSupport::TestCase
     end
   end
 
+  test "find with attached blob" do
+    records = %w[alice bob].map do |name|
+      User.create!(name: name).tap do |user|
+        user.avatar.attach create_blob(filename: "#{name}.jpg")
+      end
+    end
+
+    users = User.where(id: records.map(&:id)).with_attached_avatar.all
+
+    assert_equal "alice.jpg", users.first.avatar.filename.to_s
+    assert_equal "bob.jpg", users.second.avatar.filename.to_s
+  end
+
 
   test "attach existing blobs" do
     @user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "wonky.jpg")
@@ -101,6 +194,48 @@ class ActiveStorage::AttachmentsTest < ActiveSupport::TestCase
     assert_equal "country.jpg", @user.highlights.second.filename.to_s
   end
 
+  test "attach blobs to new record" do
+    user = User.new(name: "Jason")
+
+    assert_no_changes -> { user.new_record? } do
+      assert_no_difference -> { ActiveStorage::Attachment.count } do
+        user.highlights.attach(
+          { io: StringIO.new("STUFF"), filename: "town.jpg", content_type: "image/jpg" },
+          { io: StringIO.new("IT"), filename: "country.jpg", content_type: "image/jpg" })
+      end
+    end
+
+    assert user.highlights.attached?
+    assert_equal "town.jpg", user.highlights.first.filename.to_s
+    assert_equal "country.jpg", user.highlights.second.filename.to_s
+
+    assert_difference -> { ActiveStorage::Attachment.count }, +2 do
+      user.save!
+    end
+
+    assert user.reload.highlights.attached?
+    assert_equal "town.jpg", user.highlights.first.filename.to_s
+    assert_equal "country.jpg", user.highlights.second.filename.to_s
+  end
+
+  test "build new record with attached blobs" do
+    assert_no_difference -> { ActiveStorage::Attachment.count } do
+      @user = User.new(name: "Jason", highlights: [
+        { io: StringIO.new("STUFF"), filename: "town.jpg", content_type: "image/jpg" },
+        { io: StringIO.new("IT"), filename: "country.jpg", content_type: "image/jpg" }])
+    end
+
+    assert @user.new_record?
+    assert @user.highlights.attached?
+    assert_equal "town.jpg", @user.highlights.first.filename.to_s
+    assert_equal "country.jpg", @user.highlights.second.filename.to_s
+
+    @user.save!
+    assert @user.reload.highlights.attached?
+    assert_equal "town.jpg", @user.highlights.first.filename.to_s
+    assert_equal "country.jpg", @user.highlights.second.filename.to_s
+  end
+
   test "find attached blobs" do
     @user.highlights.attach(
       { io: StringIO.new("STUFF"), filename: "town.jpg", content_type: "image/jpg" },
@@ -122,6 +257,68 @@ class ActiveStorage::AttachmentsTest < ActiveSupport::TestCase
     assert_equal "town.jpg", @user.highlights_attachments.first.blob.filename.to_s
   end
 
+  test "analyze newly-attached blobs" do
+    perform_enqueued_jobs do
+      @user.highlights.attach(
+        create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg"),
+        create_file_blob(filename: "video.mp4", content_type: "video/mp4"))
+    end
+
+    assert_equal 4104, @user.highlights.first.metadata[:width]
+    assert_equal 2736, @user.highlights.first.metadata[:height]
+
+    assert_equal 640, @user.highlights.second.metadata[:width]
+    assert_equal 480, @user.highlights.second.metadata[:height]
+  end
+
+  test "analyze attached blobs only once" do
+    blobs = [
+      create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg"),
+      create_file_blob(filename: "video.mp4", content_type: "video/mp4")
+    ]
+
+    perform_enqueued_jobs do
+      @user.highlights.attach(blobs)
+    end
+
+    assert blobs.each(&:reload).all?(&:analyzed?)
+
+    @user.highlights.attachments.destroy_all
+
+    assert_no_enqueued_jobs do
+      @user.highlights.attach(blobs)
+    end
+  end
+
+  test "preserve existing metadata when analyzing newly-attached blobs" do
+    blobs = [
+      create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg", metadata: { foo: "bar" }),
+      create_file_blob(filename: "video.mp4", content_type: "video/mp4", metadata: { foo: "bar" })
+    ]
+
+    perform_enqueued_jobs do
+      @user.highlights.attach(blobs)
+    end
+
+    blobs.each do |blob|
+      assert_equal "bar", blob.reload.metadata[:foo]
+    end
+  end
+
+  test "detach blobs" do
+    @user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "wonky.jpg")
+    highlight_blob_ids = @user.highlights.collect { |highlight| highlight.blob.id }
+    highlight_keys = @user.highlights.collect(&:key)
+
+    @user.highlights.detach
+    assert_not @user.highlights.attached?
+
+    assert ActiveStorage::Blob.exists?(highlight_blob_ids.first)
+    assert ActiveStorage::Blob.exists?(highlight_blob_ids.second)
+
+    assert ActiveStorage::Blob.service.exist?(highlight_keys.first)
+    assert ActiveStorage::Blob.service.exist?(highlight_keys.second)
+  end
 
   test "purge attached blobs" do
     @user.highlights.attach create_blob(filename: "funky.jpg"), create_blob(filename: "wonky.jpg")
diff --git a/activestorage/test/models/blob_test.rb b/activestorage/test/models/blob_test.rb
index 6e815997ba..f94e65ed77 100644
--- a/activestorage/test/models/blob_test.rb
+++ b/activestorage/test/models/blob_test.rb
@@ -41,13 +41,21 @@ class ActiveStorage::BlobTest < ActiveSupport::TestCase
     end
   end
 
-  test "purge removes from external service" do
+  test "purge deletes file from external service" do
     blob = create_blob
 
     blob.purge
     assert_not ActiveStorage::Blob.service.exist?(blob.key)
   end
 
+  test "purge deletes variants from external service" do
+    blob = create_file_blob
+    variant = blob.variant(resize: "100>").processed
+
+    blob.purge
+    assert_not ActiveStorage::Blob.service.exist?(variant.key)
+  end
+
   private
     def expected_url_for(blob, disposition: :inline)
       query_string = { content_type: blob.content_type, disposition: "#{disposition}; #{blob.filename.parameters}" }.to_param
diff --git a/activestorage/test/models/preview_test.rb b/activestorage/test/models/preview_test.rb
new file mode 100644
index 0000000000..bcd8442f4b
--- /dev/null
+++ b/activestorage/test/models/preview_test.rb
@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::PreviewTest < ActiveSupport::TestCase
+  test "previewing a PDF" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+    preview = blob.preview(resize: "640x280").processed
+
+    assert preview.image.attached?
+    assert_equal "report.png", preview.image.filename.to_s
+    assert_equal "image/png", preview.image.content_type
+
+    image = read_image(preview.image)
+    assert_equal 612, image.width
+    assert_equal 792, image.height
+  end
+
+  test "previewing an MP4 video" do
+    blob = create_file_blob(filename: "video.mp4", content_type: "video/mp4")
+    preview = blob.preview(resize: "640x280").processed
+
+    assert preview.image.attached?
+    assert_equal "video.png", preview.image.filename.to_s
+    assert_equal "image/png", preview.image.content_type
+
+    image = read_image(preview.image)
+    assert_equal 640, image.width
+    assert_equal 480, image.height
+  end
+
+  test "previewing an unpreviewable blob" do
+    blob = create_file_blob
+
+    assert_raises ActiveStorage::Blob::UnpreviewableError do
+      blob.preview resize: "640x280"
+    end
+  end
+end
diff --git a/activestorage/test/models/representation_test.rb b/activestorage/test/models/representation_test.rb
new file mode 100644
index 0000000000..29fe61aee4
--- /dev/null
+++ b/activestorage/test/models/representation_test.rb
@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+class ActiveStorage::RepresentationTest < ActiveSupport::TestCase
+  test "representing an image" do
+    blob = create_file_blob
+    representation = blob.representation(resize: "100x100").processed
+
+    image = read_image(representation.image)
+    assert_equal 100, image.width
+    assert_equal 67, image.height
+  end
+
+  test "representing a PDF" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+    representation = blob.representation(resize: "640x280").processed
+
+    image = read_image(representation.image)
+    assert_equal 612, image.width
+    assert_equal 792, image.height
+  end
+
+  test "representing an MP4 video" do
+    blob = create_file_blob(filename: "video.mp4", content_type: "video/mp4")
+    representation = blob.representation(resize: "640x280").processed
+
+    image = read_image(representation.image)
+    assert_equal 640, image.width
+    assert_equal 480, image.height
+  end
+
+  test "representing an unrepresentable blob" do
+    blob = create_blob
+
+    assert_raises ActiveStorage::Blob::UnrepresentableError do
+      blob.representation resize: "100x100"
+    end
+  end
+end
diff --git a/activestorage/test/models/variant_test.rb b/activestorage/test/models/variant_test.rb
index ca112ab907..b7d20ab55a 100644
--- a/activestorage/test/models/variant_test.rb
+++ b/activestorage/test/models/variant_test.rb
@@ -5,14 +5,14 @@ require "database/setup"
 
 class ActiveStorage::VariantTest < ActiveSupport::TestCase
   setup do
-    @blob = create_image_blob filename: "racecar.jpg"
+    @blob = create_file_blob filename: "racecar.jpg"
   end
 
   test "resized variation" do
     variant = @blob.variant(resize: "100x100").processed
     assert_match(/racecar\.jpg/, variant.service_url)
 
-    image = read_image_variant(variant)
+    image = read_image(variant)
     assert_equal 100, image.width
     assert_equal 67, image.height
   end
@@ -21,9 +21,14 @@ class ActiveStorage::VariantTest < ActiveSupport::TestCase
     variant = @blob.variant(resize: "100x100", monochrome: true).processed
     assert_match(/racecar\.jpg/, variant.service_url)
 
-    image = read_image_variant(variant)
+    image = read_image(variant)
     assert_equal 100, image.width
     assert_equal 67, image.height
     assert_match(/Gray/, image.colorspace)
   end
+
+  test "service_url doesn't grow in length despite long variant options" do
+    variant = @blob.variant(font: "a" * 10_000).processed
+    assert_operator variant.service_url.length, :<, 500
+  end
 end
diff --git a/activestorage/test/previewer/pdf_previewer_test.rb b/activestorage/test/previewer/pdf_previewer_test.rb
new file mode 100644
index 0000000000..fe32f39be4
--- /dev/null
+++ b/activestorage/test/previewer/pdf_previewer_test.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+require "active_storage/previewer/pdf_previewer"
+
+class ActiveStorage::Previewer::PDFPreviewerTest < ActiveSupport::TestCase
+  setup do
+    @blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+  end
+
+  test "previewing a PDF document" do
+    ActiveStorage::Previewer::PDFPreviewer.new(@blob).preview do |attachable|
+      assert_equal "image/png", attachable[:content_type]
+      assert_equal "report.png", attachable[:filename]
+
+      image = MiniMagick::Image.read(attachable[:io])
+      assert_equal 612, image.width
+      assert_equal 792, image.height
+    end
+  end
+end
diff --git a/activestorage/test/previewer/video_previewer_test.rb b/activestorage/test/previewer/video_previewer_test.rb
new file mode 100644
index 0000000000..dba9b0d7e2
--- /dev/null
+++ b/activestorage/test/previewer/video_previewer_test.rb
@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "test_helper"
+require "database/setup"
+
+require "active_storage/previewer/video_previewer"
+
+class ActiveStorage::Previewer::VideoPreviewerTest < ActiveSupport::TestCase
+  setup do
+    @blob = create_file_blob(filename: "video.mp4", content_type: "video/mp4")
+  end
+
+  test "previewing an MP4 video" do
+    ActiveStorage::Previewer::VideoPreviewer.new(@blob).preview do |attachable|
+      assert_equal "image/png", attachable[:content_type]
+      assert_equal "video.png", attachable[:filename]
+
+      image = MiniMagick::Image.read(attachable[:io])
+      assert_equal 640, image.width
+      assert_equal 480, image.height
+    end
+  end
+end
diff --git a/activestorage/test/service/azure_storage_service_test.rb b/activestorage/test/service/azure_storage_service_test.rb
index 4729bdfbc5..be31bbe858 100644
--- a/activestorage/test/service/azure_storage_service_test.rb
+++ b/activestorage/test/service/azure_storage_service_test.rb
@@ -11,9 +11,9 @@ if SERVICE_CONFIGURATIONS[:azure]
 
     test "signed URL generation" do
       url = @service.url(FIXTURE_KEY, expires_in: 5.minutes,
-        disposition: "inline; filename=\"avatar.png\"", filename: "avatar.png", content_type: "image/png")
+        disposition: :inline, filename: ActiveStorage::Filename.new("avatar.png"), content_type: "image/png")
 
-      assert_match(/(\S+)&rscd=inline%3B\+filename%3D%22avatar.png%22&rsct=image%2Fpng/, url)
+      assert_match(/(\S+)&rscd=inline%3B\+filename%3D%22avatar\.png%22%3B\+filename\*%3DUTF-8%27%27avatar\.png&rsct=image%2Fpng/, url)
       assert_match SERVICE_CONFIGURATIONS[:azure][:container], url
     end
   end
diff --git a/activestorage/test/service/configurations.example.yml b/activestorage/test/service/configurations.example.yml
index 56ed37be5d..43cc013bc8 100644
--- a/activestorage/test/service/configurations.example.yml
+++ b/activestorage/test/service/configurations.example.yml
@@ -7,7 +7,7 @@
 #
 # gcs:
 #   service: GCS
-#   keyfile: {
+#   credentials: {
 #     type: "service_account",
 #     project_id: "",
 #     private_key_id: "",
diff --git a/activestorage/test/service/disk_service_test.rb b/activestorage/test/service/disk_service_test.rb
index e07d1d88bc..4a6361b920 100644
--- a/activestorage/test/service/disk_service_test.rb
+++ b/activestorage/test/service/disk_service_test.rb
@@ -9,6 +9,6 @@ class ActiveStorage::Service::DiskServiceTest < ActiveSupport::TestCase
 
   test "url generation" do
     assert_match(/rails\/active_storage\/disk\/.*\/avatar\.png\?content_type=image%2Fpng&disposition=inline/,
-      @service.url(FIXTURE_KEY, expires_in: 5.minutes, disposition: "inline; filename=\"avatar.png\"", filename: "avatar.png", content_type: "image/png"))
+      @service.url(FIXTURE_KEY, expires_in: 5.minutes, disposition: :inline, filename: ActiveStorage::Filename.new("avatar.png"), content_type: "image/png"))
   end
 end
diff --git a/activestorage/test/service/gcs_service_test.rb b/activestorage/test/service/gcs_service_test.rb
index f664cee90b..7efcd60fb7 100644
--- a/activestorage/test/service/gcs_service_test.rb
+++ b/activestorage/test/service/gcs_service_test.rb
@@ -32,12 +32,21 @@ if SERVICE_CONFIGURATIONS[:gcs]
     end
 
     test "signed URL generation" do
-      freeze_time do
-        url = SERVICE.bucket.signed_url(FIXTURE_KEY, expires: 120) +
-          "&response-content-disposition=inline%3B+filename%3D%22test.txt%22" +
-          "&response-content-type=text%2Fplain"
+      assert_match(/storage\.googleapis\.com\/.*response-content-disposition=inline.*test\.txt.*response-content-type=text%2Fplain/,
+        @service.url(FIXTURE_KEY, expires_in: 2.minutes, disposition: :inline, filename: ActiveStorage::Filename.new("test.txt"), content_type: "text/plain"))
+    end
+
+    test "signed URL response headers" do
+      begin
+        key  = SecureRandom.base58(24)
+        data = "Something else entirely!"
+        @service.upload(key, StringIO.new(data), checksum: Digest::MD5.base64digest(data))
 
-        assert_equal url, @service.url(FIXTURE_KEY, expires_in: 2.minutes, disposition: "inline; filename=\"test.txt\"", filename: "test.txt", content_type: "text/plain")
+        url = @service.url(key, expires_in: 2.minutes, disposition: :inline, filename: ActiveStorage::Filename.new("test.txt"), content_type: "text/plain")
+        response = Net::HTTP.get_response(URI(url))
+        assert_equal "text/plain", response.header["Content-Type"]
+      ensure
+        @service.delete key
       end
     end
   end
diff --git a/activestorage/test/service/mirror_service_test.rb b/activestorage/test/service/mirror_service_test.rb
index 93e86eff70..92101b1282 100644
--- a/activestorage/test/service/mirror_service_test.rb
+++ b/activestorage/test/service/mirror_service_test.rb
@@ -47,9 +47,11 @@ class ActiveStorage::Service::MirrorServiceTest < ActiveSupport::TestCase
   end
 
   test "URL generation in primary service" do
+    filename = ActiveStorage::Filename.new("test.txt")
+
     freeze_time do
-      assert_equal SERVICE.primary.url(FIXTURE_KEY, expires_in: 2.minutes, disposition: :inline, filename: "test.txt", content_type: "text/plain"),
-        @service.url(FIXTURE_KEY, expires_in: 2.minutes, disposition: :inline, filename: "test.txt", content_type: "text/plain")
+      assert_equal SERVICE.primary.url(FIXTURE_KEY, expires_in: 2.minutes, disposition: :inline, filename: filename, content_type: "text/plain"),
+        @service.url(FIXTURE_KEY, expires_in: 2.minutes, disposition: :inline, filename: filename, content_type: "text/plain")
     end
   end
 
diff --git a/activestorage/test/service/s3_service_test.rb b/activestorage/test/service/s3_service_test.rb
index c07d6396b1..c3818422aa 100644
--- a/activestorage/test/service/s3_service_test.rb
+++ b/activestorage/test/service/s3_service_test.rb
@@ -33,7 +33,7 @@ if SERVICE_CONFIGURATIONS[:s3] && SERVICE_CONFIGURATIONS[:s3][:access_key_id].pr
 
     test "signed URL generation" do
       url = @service.url(FIXTURE_KEY, expires_in: 5.minutes,
-        disposition: "inline; filename=\"avatar.png\"", filename: "avatar.png", content_type: "image/png")
+        disposition: :inline, filename: ActiveStorage::Filename.new("avatar.png"), content_type: "image/png")
 
       assert_match(/s3\.(\S+)?amazonaws.com.*response-content-disposition=inline.*avatar\.png.*response-content-type=image%2Fpng/, url)
       assert_match SERVICE_CONFIGURATIONS[:s3][:bucket], url
diff --git a/activestorage/test/service/shared_service_tests.rb b/activestorage/test/service/shared_service_tests.rb
index a9e1cb6ce9..ce28c4393a 100644
--- a/activestorage/test/service/shared_service_tests.rb
+++ b/activestorage/test/service/shared_service_tests.rb
@@ -50,6 +50,16 @@ module ActiveStorage::Service::SharedServiceTests
       assert_equal FIXTURE_DATA, @service.download(FIXTURE_KEY)
     end
 
+    test "downloading in chunks" do
+      chunks = []
+
+      @service.download(FIXTURE_KEY) do |chunk|
+        chunks << chunk
+      end
+
+      assert_equal [ FIXTURE_DATA ], chunks
+    end
+
     test "existing" do
       assert @service.exist?(FIXTURE_KEY)
       assert_not @service.exist?(FIXTURE_KEY + "nonsense")
@@ -65,5 +75,22 @@ module ActiveStorage::Service::SharedServiceTests
         @service.delete SecureRandom.base58(24)
       end
     end
+
+    test "deleting by prefix" do
+      begin
+        @service.upload("a/a/a", StringIO.new(FIXTURE_DATA))
+        @service.upload("a/a/b", StringIO.new(FIXTURE_DATA))
+        @service.upload("a/b/a", StringIO.new(FIXTURE_DATA))
+
+        @service.delete_prefixed("a/a/")
+        assert_not @service.exist?("a/a/a")
+        assert_not @service.exist?("a/a/b")
+        assert @service.exist?("a/b/a")
+      ensure
+        @service.delete("a/a/a")
+        @service.delete("a/a/b")
+        @service.delete("a/b/a")
+      end
+    end
   end
 end
diff --git a/activestorage/test/template/image_tag_test.rb b/activestorage/test/template/image_tag_test.rb
index dedc58452e..80f183e0e3 100644
--- a/activestorage/test/template/image_tag_test.rb
+++ b/activestorage/test/template/image_tag_test.rb
@@ -7,7 +7,7 @@ class ActiveStorage::ImageTagTest < ActionView::TestCase
   tests ActionView::Helpers::AssetTagHelper
 
   setup do
-    @blob = create_image_blob filename: "racecar.jpg"
+    @blob = create_file_blob filename: "racecar.jpg"
   end
 
   test "blob" do
@@ -19,6 +19,12 @@ class ActiveStorage::ImageTagTest < ActionView::TestCase
     assert_dom_equal %(<img src="#{polymorphic_url variant}" />), image_tag(variant)
   end
 
+  test "preview" do
+    blob = create_file_blob(filename: "report.pdf", content_type: "application/pdf")
+    preview = blob.preview(resize: "100x100")
+    assert_dom_equal %(<img src="#{polymorphic_url preview}" />), image_tag(preview)
+  end
+
   test "attachment" do
     attachment = ActiveStorage::Attachment.new(blob: @blob)
     assert_dom_equal %(<img src="#{polymorphic_url attachment}" />), image_tag(attachment)
diff --git a/activestorage/test/test_helper.rb b/activestorage/test/test_helper.rb
index 2a969fa326..aaf1d452ea 100644
--- a/activestorage/test/test_helper.rb
+++ b/activestorage/test/test_helper.rb
@@ -1,11 +1,13 @@
 # frozen_string_literal: true
 
-require File.expand_path("../../test/dummy/config/environment.rb", __FILE__)
+ENV["RAILS_ENV"] ||= "test"
+require_relative "dummy/config/environment.rb"
 
 require "bundler/setup"
 require "active_support"
 require "active_support/test_case"
 require "active_support/testing/autorun"
+require "mini_magick"
 
 begin
   require "byebug"
@@ -22,7 +24,7 @@ Minitest.backtrace_filter = Minitest::BacktraceFilter.new
 
 require "yaml"
 SERVICE_CONFIGURATIONS = begin
-  erb = ERB.new(Pathname.new(File.expand_path("../service/configurations.yml", __FILE__)).read)
+  erb = ERB.new(Pathname.new(File.expand_path("service/configurations.yml", __dir__)).read)
   configuration = YAML.load(erb.result) || {}
   configuration.deep_symbolize_keys
 rescue Errno::ENOENT
@@ -32,30 +34,28 @@ end
 
 require "tmpdir"
 ActiveStorage::Blob.service = ActiveStorage::Service::DiskService.new(root: Dir.mktmpdir("active_storage_tests"))
-ActiveStorage::Service.logger = ActiveSupport::Logger.new(nil)
 
+ActiveStorage.logger = ActiveSupport::Logger.new(nil)
 ActiveStorage.verifier = ActiveSupport::MessageVerifier.new("Testing")
 
 class ActiveSupport::TestCase
-  self.file_fixture_path = File.expand_path("../fixtures/files", __FILE__)
+  self.file_fixture_path = File.expand_path("fixtures/files", __dir__)
 
   private
     def create_blob(data: "Hello world!", filename: "hello.txt", content_type: "text/plain")
       ActiveStorage::Blob.create_after_upload! io: StringIO.new(data), filename: filename, content_type: content_type
     end
 
-    def create_image_blob(filename: "racecar.jpg", content_type: "image/jpeg")
-      ActiveStorage::Blob.create_after_upload! \
-        io: file_fixture(filename).open,
-        filename: filename, content_type: content_type
+    def create_file_blob(filename: "racecar.jpg", content_type: "image/jpeg", metadata: nil)
+      ActiveStorage::Blob.create_after_upload! io: file_fixture(filename).open, filename: filename, content_type: content_type, metadata: metadata
     end
 
     def create_blob_before_direct_upload(filename: "hello.txt", byte_size:, checksum:, content_type: "text/plain")
       ActiveStorage::Blob.create_before_direct_upload! filename: filename, byte_size: byte_size, checksum: checksum, content_type: content_type
     end
 
-    def read_image_variant(variant)
-      MiniMagick::Image.open variant.service.send(:path_for, variant.key)
+    def read_image(blob_or_variant)
+      MiniMagick::Image.open blob_or_variant.service.send(:path_for, blob_or_variant.key)
     end
 end
 
diff --git a/activestorage/yarn.lock b/activestorage/yarn.lock
index dd09577445..41742be201 100644
--- a/activestorage/yarn.lock
+++ b/activestorage/yarn.lock
@@ -1219,12 +1219,6 @@ escope@^3.6.0:
     esrecurse "^4.1.0"
     estraverse "^4.1.1"
 
-eslint-config-airbnb-base@^11.3.1:
-  version "11.3.1"
-  resolved "https://registry.yarnpkg.com/eslint-config-airbnb-base/-/eslint-config-airbnb-base-11.3.1.tgz#c0ab108c9beed503cb999e4c60f4ef98eda0ed30"
-  dependencies:
-    eslint-restricted-globals "^0.1.1"
-
 eslint-import-resolver-node@^0.3.1:
   version "0.3.1"
   resolved "https://registry.yarnpkg.com/eslint-import-resolver-node/-/eslint-import-resolver-node-0.3.1.tgz#4422574cde66a9a7b099938ee4d508a199e0e3cc"
@@ -1254,10 +1248,6 @@ eslint-plugin-import@^2.7.0:
     minimatch "^3.0.3"
     read-pkg-up "^2.0.0"
 
-eslint-restricted-globals@^0.1.1:
-  version "0.1.1"
-  resolved "https://registry.yarnpkg.com/eslint-restricted-globals/-/eslint-restricted-globals-0.1.1.tgz#35f0d5cbc64c2e3ed62e93b4b1a7af05ba7ed4d7"
-
 eslint-scope@^3.7.1:
   version "3.7.1"
   resolved "https://registry.yarnpkg.com/eslint-scope/-/eslint-scope-3.7.1.tgz#3d63c3edfda02e06e01a452ad88caacc7cdcb6e8"