activestorage 6.1.4.1 → 7.0.0.rc2

data/app/controllers/active_storage/base_controller.rb

@@ -2,18 +2,9 @@
 
 # The base class for all Active Storage controllers.
 class ActiveStorage::BaseController < ActionController::Base
-  include ActiveStorage::SetCurrent
+  include ActiveStorage::SetCurrent, ActiveStorage::Streaming
 
   protect_from_forgery with: :exception
 
   self.etag_with_template_digest = false
-
-  private
-    def stream(blob)
-      blob.download do |chunk|
-        response.stream.write chunk
-      end
-    ensure
-      response.stream.close
-    end
 end

data/app/controllers/active_storage/blobs/proxy_controller.rb

@@ -1,14 +1,24 @@
 # frozen_string_literal: true
 
 # Proxy files through application. This avoids having a redirect and makes files easier to cache.
+#
+# WARNING: All Active Storage controllers are publicly accessible by default. The
+# generated URLs are hard to guess, but permanent by design. If your files
+# require a higher level of protection consider implementing
+# {Authenticated Controllers}[https://edgeguides.rubyonrails.org/active_storage_overview.html#authenticated-controllers].
 class ActiveStorage::Blobs::ProxyController < ActiveStorage::BaseController
   include ActiveStorage::SetBlob
-  include ActiveStorage::SetHeaders
 
   def show
-    http_cache_forever public: true do
-      set_content_headers_from @blob
-      stream @blob
+    if request.headers["Range"].present?
+      send_blob_byte_range_data @blob, request.headers["Range"]
+    else
+      http_cache_forever public: true do
+        response.headers["Accept-Ranges"] = "bytes"
+        response.headers["Content-Length"] = @blob.byte_size.to_s
+
+        send_blob_stream @blob
+      end
     end
   end
 end

data/app/controllers/active_storage/blobs/redirect_controller.rb

@@ -1,14 +1,16 @@
 # frozen_string_literal: true
 
 # Take a signed permanent reference for a blob and turn it into an expiring service URL for download.
-# Note: These URLs are publicly accessible. If you need to enforce access protection beyond the
-# security-through-obscurity factor of the signed blob references, you'll need to implement your own
-# authenticated redirection controller.
+#
+# WARNING: All Active Storage controllers are publicly accessible by default. The
+# generated URLs are hard to guess, but permanent by design. If your files
+# require a higher level of protection consider implementing
+# {Authenticated Controllers}[https://edgeguides.rubyonrails.org/active_storage_overview.html#authenticated-controllers].
 class ActiveStorage::Blobs::RedirectController < ActiveStorage::BaseController
   include ActiveStorage::SetBlob
 
   def show
     expires_in ActiveStorage.service_urls_expire_in
-    redirect_to @blob.url(disposition: params[:disposition])
+    redirect_to @blob.url(disposition: params[:disposition]), allow_other_host: true
   end
 end

data/app/controllers/active_storage/direct_uploads_controller.rb

@@ -4,8 +4,10 @@
 # When the client-side upload is completed, the signed_blob_id can be submitted as part of the form to reference
 # the blob that was created up front.
 class ActiveStorage::DirectUploadsController < ActiveStorage::BaseController
+  include ActiveStorage::DirectUploadToken
+
   def create
-    blob = ActiveStorage::Blob.create_before_direct_upload!(**blob_args)
+    blob = ActiveStorage::Blob.create_before_direct_upload!(**blob_args.merge(service_name: verified_service_name))
     render json: direct_upload_json(blob)
   end
 
@@ -14,6 +16,10 @@ class ActiveStorage::DirectUploadsController < ActiveStorage::BaseController
       params.require(:blob).permit(:filename, :byte_size, :checksum, :content_type, metadata: {}).to_h.symbolize_keys
     end
 
+    def verified_service_name
+      ActiveStorage::DirectUploadToken.verify_direct_upload_token(params[:direct_upload_token], params[:attachment_name], session)
+    end
+
     def direct_upload_json(blob)
       blob.as_json(root: false, methods: :signed_id).merge(direct_upload: {
         url: blob.service_url_for_direct_upload,

data/app/controllers/active_storage/disk_controller.rb

@@ -23,6 +23,7 @@ class ActiveStorage::DiskController < ActiveStorage::BaseController
     if token = decode_verified_token
       if acceptable_content?(token)
         named_disk_service(token[:service_name]).upload token[:key], request.body, checksum: token[:checksum]
+        head :no_content
       else
         head :unprocessable_entity
       end

data/app/controllers/active_storage/representations/base_controller.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
-class ActiveStorage::Representations::BaseController < ActiveStorage::BaseController #:nodoc:
+class ActiveStorage::Representations::BaseController < ActiveStorage::BaseController # :nodoc:
   include ActiveStorage::SetBlob
 
   before_action :set_representation
 
   private
+    def blob_scope
+      ActiveStorage::Blob.scope_for_strict_loading
+    end
+
     def set_representation
       @representation = @blob.representation(params[:variation_key]).processed
     rescue ActiveSupport::MessageVerifier::InvalidSignature

data/app/controllers/active_storage/representations/proxy_controller.rb

@@ -1,13 +1,15 @@
 # frozen_string_literal: true
 
 # Proxy files through application. This avoids having a redirect and makes files easier to cache.
+#
+# WARNING: All Active Storage controllers are publicly accessible by default. The
+# generated URLs are hard to guess, but permanent by design. If your files
+# require a higher level of protection consider implementing
+# {Authenticated Controllers}[https://edgeguides.rubyonrails.org/active_storage_overview.html#authenticated-controllers].
 class ActiveStorage::Representations::ProxyController < ActiveStorage::Representations::BaseController
-  include ActiveStorage::SetHeaders
-
   def show
     http_cache_forever public: true do
-      set_content_headers_from @representation.image
-      stream @representation
+      send_blob_stream @representation.image
     end
   end
 end

data/app/controllers/active_storage/representations/redirect_controller.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 # Take a signed permanent reference for a blob representation and turn it into an expiring service URL for download.
-# Note: These URLs are publicly accessible. If you need to enforce access protection beyond the
-# security-through-obscurity factor of the signed blob and variation reference, you'll need to implement your own
-# authenticated redirection controller.
+#
+# WARNING: All Active Storage controllers are publicly accessible by default. The
+# generated URLs are hard to guess, but permanent by design. If your files
+# require a higher level of protection consider implementing
+# {Authenticated Controllers}[https://edgeguides.rubyonrails.org/active_storage_overview.html#authenticated-controllers].
 class ActiveStorage::Representations::RedirectController < ActiveStorage::Representations::BaseController
   def show
     expires_in ActiveStorage.service_urls_expire_in
-    redirect_to @representation.url(disposition: params[:disposition])
+    redirect_to @representation.url(disposition: params[:disposition]), allow_other_host: true
   end
 end

data/app/controllers/concerns/active_storage/set_blob.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-module ActiveStorage::SetBlob #:nodoc:
+module ActiveStorage::SetBlob # :nodoc:
   extend ActiveSupport::Concern
 
   included do
@@ -9,8 +9,12 @@ module ActiveStorage::SetBlob #:nodoc:
 
   private
     def set_blob
-      @blob = ActiveStorage::Blob.find_signed!(params[:signed_blob_id] || params[:signed_id])
+      @blob = blob_scope.find_signed!(params[:signed_blob_id] || params[:signed_id])
     rescue ActiveSupport::MessageVerifier::InvalidSignature
       head :not_found
     end
+
+    def blob_scope
+      ActiveStorage::Blob
+    end
 end

data/app/controllers/concerns/active_storage/set_current.rb

@@ -1,15 +1,15 @@
 # frozen_string_literal: true
 
-# Sets the <tt>ActiveStorage::Current.host</tt> attribute, which the disk service uses to generate URLs.
+# Sets the <tt>ActiveStorage::Current.url_options</tt> attribute, which the disk service uses to generate URLs.
 # Include this concern in custom controllers that call ActiveStorage::Blob#url,
 # ActiveStorage::Variant#url, or ActiveStorage::Preview#url so the disk service can
-# generate URLs using the same host, protocol, and base path as the current request.
+# generate URLs using the same host, protocol, and port as the current request.
 module ActiveStorage::SetCurrent
   extend ActiveSupport::Concern
 
   included do
     before_action do
-      ActiveStorage::Current.host = request.base_url
+      ActiveStorage::Current.url_options = { protocol: request.protocol, host: request.host, port: request.port }
     end
   end
 end

data/app/controllers/concerns/active_storage/streaming.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module ActiveStorage::Streaming
+  DEFAULT_BLOB_STREAMING_DISPOSITION = "inline"
+
+  include ActionController::DataStreaming
+  include ActionController::Live
+
+  private
+    # Stream the blob in byte ranges specified through the header
+    def send_blob_byte_range_data(blob, range_header, disposition: nil)
+      ranges = Rack::Utils.get_byte_ranges(range_header, blob.byte_size)
+
+      return head(:range_not_satisfiable) if ranges.blank? || ranges.all?(&:blank?)
+
+      if ranges.length == 1
+        range = ranges.first
+        content_type = blob.content_type_for_serving
+        data = blob.download_chunk(range)
+
+        response.headers["Content-Range"] = "bytes #{range.begin}-#{range.end}/#{blob.byte_size}"
+      else
+        boundary = SecureRandom.hex
+        content_type = "multipart/byteranges; boundary=#{boundary}"
+        data = +""
+
+        ranges.compact.each do |range|
+          chunk = blob.download_chunk(range)
+
+          data << "\r\n--#{boundary}\r\n"
+          data << "Content-Type: #{blob.content_type_for_serving}\r\n"
+          data << "Content-Range: bytes #{range.begin}-#{range.end}/#{blob.byte_size}\r\n\r\n"
+          data << chunk
+        end
+
+        data << "\r\n--#{boundary}--\r\n"
+      end
+
+      response.headers["Accept-Ranges"] = "bytes"
+      response.headers["Content-Length"] = data.length.to_s
+
+      send_data(
+        data,
+        disposition: blob.forced_disposition_for_serving || disposition || DEFAULT_BLOB_STREAMING_DISPOSITION,
+        filename: blob.filename.sanitized,
+        status: :partial_content,
+        type: content_type
+      )
+    end
+
+    # Stream the blob from storage directly to the response. The disposition can be controlled by setting +disposition+.
+    # The content type and filename is set directly from the +blob+.
+    def send_blob_stream(blob, disposition: nil) # :doc:
+      send_stream(
+          filename: blob.filename.sanitized,
+          disposition: blob.forced_disposition_for_serving || disposition || DEFAULT_BLOB_STREAMING_DISPOSITION,
+          type: blob.content_type_for_serving) do |stream|
+        blob.download do |chunk|
+          stream.write chunk
+        end
+      end
+    end
+end

data/app/javascript/activestorage/blob_record.js

@@ -1,16 +1,19 @@
 import { getMetaValue } from "./helpers"
 
 export class BlobRecord {
-  constructor(file, checksum, url) {
+  constructor(file, checksum, url, directUploadToken, attachmentName) {
     this.file = file
 
     this.attributes = {
       filename: file.name,
       content_type: file.type || "application/octet-stream",
       byte_size: file.size,
-      checksum: checksum
+      checksum: checksum,
     }
 
+    this.directUploadToken = directUploadToken
+    this.attachmentName = attachmentName
+
     this.xhr = new XMLHttpRequest
     this.xhr.open("POST", url, true)
     this.xhr.responseType = "json"
@@ -43,7 +46,11 @@ export class BlobRecord {
 
   create(callback) {
     this.callback = callback
-    this.xhr.send(JSON.stringify({ blob: this.attributes }))
+    this.xhr.send(JSON.stringify({
+      blob: this.attributes,
+      direct_upload_token: this.directUploadToken,
+      attachment_name: this.attachmentName
+    }))
   }
 
   requestDidLoad(event) {

data/app/javascript/activestorage/direct_upload.js

@@ -5,10 +5,12 @@ import { BlobUpload } from "./blob_upload"
 let id = 0
 
 export class DirectUpload {
-  constructor(file, url, delegate) {
+  constructor(file, url, serviceName, attachmentName, delegate) {
     this.id = ++id
     this.file = file
     this.url = url
+    this.serviceName = serviceName
+    this.attachmentName = attachmentName
     this.delegate = delegate
   }
 
@@ -19,7 +21,7 @@ export class DirectUpload {
         return
       }
 
-      const blob = new BlobRecord(this.file, checksum, this.url)
+      const blob = new BlobRecord(this.file, checksum, this.url, this.serviceName, this.attachmentName)
       notify(this.delegate, "directUploadWillCreateBlobWithXHR", blob.xhr)
 
       blob.create(error => {

data/app/javascript/activestorage/direct_upload_controller.js

@@ -5,7 +5,7 @@ export class DirectUploadController {
   constructor(input, file) {
     this.input = input
     this.file = file
-    this.directUpload = new DirectUpload(this.file, this.url, this)
+    this.directUpload = new DirectUpload(this.file, this.url, this.directUploadToken, this.attachmentName, this)
     this.dispatch("initialize")
   }
 
@@ -41,6 +41,14 @@ export class DirectUploadController {
     return this.input.getAttribute("data-direct-upload-url")
   }
 
+  get directUploadToken() {
+    return this.input.getAttribute("data-direct-upload-token")
+  }
+
+  get attachmentName() {
+    return this.input.getAttribute("data-direct-upload-attachment-name")
+  }
+
   dispatch(name, detail = {}) {
     detail.file = this.file
     detail.id = this.directUpload.id

data/app/javascript/activestorage/ujs.js

@@ -9,7 +9,7 @@ export function start() {
   if (!started) {
     started = true
     document.addEventListener("click", didClick, true)
-    document.addEventListener("submit", didSubmitForm)
+    document.addEventListener("submit", didSubmitForm, true)
     document.addEventListener("ajax:before", didSubmitRemoteElement)
   }
 }

data/app/models/active_storage/attachment.rb

@@ -7,6 +7,14 @@ require "active_support/core_ext/module/delegation"
 # on the attachments table prevents blobs from being purged if they’re still attached to any records.
 #
 # Attachments also have access to all methods from {ActiveStorage::Blob}[rdoc-ref:ActiveStorage::Blob].
+#
+# If you wish to preload attachments or blobs, you can use these scopes:
+#
+#   # preloads attachments, their corresponding blobs, and variant records (if using `ActiveStorage.track_variants`)
+#   User.all.with_attached_avatars
+#
+#   # preloads blobs and variant records (if using `ActiveStorage.track_variants`)
+#   User.first.avatars.with_all_variant_records
 class ActiveStorage::Attachment < ActiveStorage::Record
   self.table_name = "active_storage_attachments"
 
@@ -19,11 +27,13 @@ class ActiveStorage::Attachment < ActiveStorage::Record
   after_create_commit :mirror_blob_later, :analyze_blob_later
   after_destroy_commit :purge_dependent_blob_later
 
+  scope :with_all_variant_records, -> { includes(blob: :variant_records) }
+
   # Synchronously deletes the attachment and {purges the blob}[rdoc-ref:ActiveStorage::Blob#purge].
   def purge
     transaction do
       delete
-      record&.touch
+      record.touch if record&.persisted?
     end
     blob&.purge
   end
@@ -32,11 +42,30 @@ class ActiveStorage::Attachment < ActiveStorage::Record
   def purge_later
     transaction do
       delete
-      record&.touch
+      record.touch if record&.persisted?
     end
     blob&.purge_later
   end
 
+  # Returns an ActiveStorage::Variant or ActiveStorage::VariantWithRecord
+  # instance for the attachment with the set of +transformations+ provided.
+  # See ActiveStorage::Blob::Representable#variant for more information.
+  #
+  # Raises an +ArgumentError+ if +transformations+ is a +Symbol+ which is an
+  # unknown pre-defined variant of the attachment.
+  def variant(transformations)
+    case transformations
+    when Symbol
+      variant_name = transformations
+      transformations = variants.fetch(variant_name) do
+        record_model_name = record.to_model.model_name.name
+        raise ArgumentError, "Cannot find variant :#{variant_name} for #{record_model_name}##{name}"
+      end
+    end
+
+    blob.variant(transformations)
+  end
+
   private
     def analyze_blob_later
       blob.analyze_later unless blob.analyzed?
@@ -51,7 +80,11 @@ class ActiveStorage::Attachment < ActiveStorage::Record
     end
 
     def dependent
-      record.attachment_reflections[name]&.options[:dependent]
+      record.attachment_reflections[name]&.options&.fetch(:dependent, nil)
+    end
+
+    def variants
+      record.attachment_reflections[name]&.variants
     end
 end
 

data/app/models/active_storage/blob/representable.rb

@@ -12,8 +12,8 @@ module ActiveStorage::Blob::Representable
     has_one_attached :preview_image
   end
 
-  # 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:
+  # Returns an ActiveStorage::Variant or ActiveStorage::VariantWithRecord 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_to_limit: [100, 100]).processed.url
   #
@@ -28,8 +28,9 @@ module ActiveStorage::Blob::Representable
   # This will create a URL for that specific blob with that specific variant, which the ActiveStorage::RepresentationsController
   # can then produce on-demand.
   #
-  # Raises ActiveStorage::InvariableError if ImageMagick cannot transform the blob. To determine whether a blob is
-  # variable, call ActiveStorage::Blob#variable?.
+  # Raises ActiveStorage::InvariableError if the variant processor cannot
+  # transform the blob. To determine whether a blob is variable, call
+  # ActiveStorage::Blob#variable?.
   def variant(transformations)
     if variable?
       variant_class.new(self, ActiveStorage::Variation.wrap(transformations).default_to(default_variant_transformations))
@@ -38,7 +39,8 @@ module ActiveStorage::Blob::Representable
     end
   end
 
-  # Returns true if ImageMagick can transform the blob (its content type is in +ActiveStorage.variable_content_types+).
+  # Returns true if the variant processor can transform the blob (its content
+  # type is in +ActiveStorage.variable_content_types+).
   def variable?
     ActiveStorage.variable_content_types.include?(content_type)
   end