class ActiveStorage::Blob

# File activestorage/app/models/active_storage/blob.rb, line 54
def build_after_upload(io:, filename:, content_type: nil, metadata: nil, identify: true)
  new(filename: filename, content_type: content_type, metadata: metadata).tap do |blob|
    blob.upload(io, identify: identify)
  end
end

Returns a new, unsaved blob instance after the io has been uploaded to the service. When providing a content type, pass identify: false to bypass automatic content type inference.

# File activestorage/app/models/active_storage/blob.rb, line 70
def create_after_upload!(io:, filename:, content_type: nil, metadata: nil, identify: true)
  build_after_upload(io: io, filename: filename, content_type: content_type, metadata: metadata, identify: identify).tap(&:save!)
end

Returns a saved blob instance after the io has been uploaded to the service. Note, the blob is first built, then the io is uploaded, then the blob is saved. This is done this way to avoid uploading (which may take time), while having an open database transaction. When providing a content type, pass identify: false to bypass automatic content type inference.

# File activestorage/app/models/active_storage/blob.rb, line 79
def create_before_direct_upload!(filename:, byte_size:, checksum:, content_type: nil, metadata: nil)
  create! filename: filename, byte_size: byte_size, checksum: checksum, content_type: content_type, metadata: metadata
end

Returns a saved blob without uploading a file to the service. This blob will point to a key where there is no file yet. It's intended to be used together with a client-side upload, which will first create the blob in order to produce the signed URL for uploading. This signed URL points to the key generated by the blob. Once the form using the direct upload is submitted, the blob can be associated with the right record using the signed ID.

# File activestorage/app/models/active_storage/blob.rb, line 48
def find_signed(id)
  find ActiveStorage.verifier.verify(id, purpose: :blob_id)
end

You can use the signed ID of a blob to refer to it on the client side without fear of tampering. This is particularly helpful for direct uploads where the client-side needs to refer to the blob that was created ahead of the upload itself on form submission.

The signed ID is also used to create stable URLs for the blob through the BlobsController.

# File activestorage/app/models/active_storage/blob.rb, line 88
def generate_unique_secure_token
  SecureRandom.base36(28)
end

To prevent problems with case-insensitive filesystems, especially in combination with databases which treat indices as case-sensitive, all blob keys generated are going to only contain the base-36 character alphabet and will therefore be lowercase. To maintain the same or higher amount of entropy as in the base-58 encoding used by `has_secure_token` the number of bytes used is increased to 28 from the standard 24

# File activestorage/app/models/active_storage/blob.rb, line 121
def audio?
  content_type.start_with?("audio")
end

Returns true if the content_type of this blob is in the audio range, like audio/mpeg.

# File activestorage/app/models/active_storage/blob.rb, line 214
def delete
  service.delete(key)
  service.delete_prefixed("variants/#{key}/") if image?
end

Deletes the files on the service associated with the blob. This should only be done if the blob is going to be deleted as well or you will essentially have a dead reference. It's recommended to use purge and purge_later methods in most circumstances.

# File activestorage/app/models/active_storage/blob.rb, line 188
def download(&block)
  service.download key, &block
end

Downloads the file associated with this blob. If no block is given, the entire file is read into memory and returned. That'll use a lot of RAM for very large files. If a block is given, then the download is streamed and yielded in chunks.

# File activestorage/app/models/active_storage/blob.rb, line 111
def filename
  ActiveStorage::Filename.new(self[:filename])
end

Returns an ActiveStorage::Filename instance of the filename that can be queried for basename, extension, and a sanitized version of the filename that's safe to use in URLs.

# File activestorage/app/models/active_storage/blob.rb, line 116
def image?
  content_type.start_with?("image")
end

Returns true if the content_type of this blob is in the image range, like image/png.

# File activestorage/app/models/active_storage/blob.rb, line 103
def key
  # We can't wait until the record is first saved to have a key for it
  self[:key] ||= self.class.generate_unique_secure_token
end

Returns the key pointing to the file on the service that's associated with this blob. The key is the secure-token format from Rails in lower case. So it'll look like: xtapjjcjiudrlk3tmwyjgpuobabd. This key is not intended to be revealed directly to the user. Always refer to blobs using the #signed_id or a verified form of the key.

# File activestorage/app/models/active_storage/blob.rb, line 205
def open(tmpdir: nil, &block)
  service.open key, checksum: checksum,
    name: [ "ActiveStorage-#{id}-", filename.extension_with_delimiter ], tmpdir: tmpdir, &block
end

Downloads the blob to a tempfile on disk. Yields the tempfile.

The tempfile's name is prefixed with ActiveStorage- and the blob's ID. Its extension matches that of the blob.

By default, the tempfile is created in Dir.tmpdir. Pass tmpdir: to create it in a different directory:

blob.open(tmpdir: "/path/to/tmp") do |file|
  # ...
end

The tempfile is automatically closed and unlinked after the given block is executed.

Raises ActiveStorage::IntegrityError if the downloaded data does not match the blob's checksum.

# File activestorage/app/models/active_storage/blob.rb, line 222
def purge
  destroy
  delete
rescue ActiveRecord::InvalidForeignKey
end

Deletes the file on the service and then destroys the blob record. This is the recommended way to dispose of unwanted blobs. Note, though, that deleting the file off the service will initiate a HTTP connection to the service, which may be slow or prevented, so you should not use this method inside a transaction or in callbacks. Use purge_later instead.

# File activestorage/app/models/active_storage/blob.rb, line 230
def purge_later
  ActiveStorage::PurgeJob.perform_later(self)
end

Enqueues an ActiveStorage::PurgeJob to call purge. This is the recommended way to purge blobs from a transaction, an Active Record callback, or in any other real-time scenario.

# File activestorage/app/models/active_storage/blob.rb, line 154
def service_headers_for_direct_upload
  service.headers_for_direct_upload key, filename: filename, content_type: content_type, content_length: byte_size, checksum: checksum
end

Returns a Hash of headers for service_url_for_direct_upload requests.

# File activestorage/app/models/active_storage/blob.rb, line 140
def service_url(expires_in: ActiveStorage.service_urls_expire_in, disposition: :inline, filename: nil, **options)
  filename = ActiveStorage::Filename.wrap(filename || self.filename)

  service.url key, expires_in: expires_in, filename: filename, content_type: content_type_for_service_url,
    disposition: forced_disposition_for_service_url || disposition, **options
end

Returns the URL of the blob on the service. This URL is intended to be short-lived for security and not used directly 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.

# File activestorage/app/models/active_storage/blob.rb, line 149
def service_url_for_direct_upload(expires_in: ActiveStorage.service_urls_expire_in)
  service.url_for_direct_upload key, expires_in: expires_in, content_type: content_type, content_length: byte_size, checksum: checksum
end

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.

# File activestorage/app/models/active_storage/blob.rb, line 95
def signed_id
  ActiveStorage.verifier.generate(id, purpose: :blob_id)
end

Returns a signed ID for this blob that's suitable for reference on the client-side without fear of tampering. It uses the framework-wide verifier on ActiveStorage.verifier, but with a dedicated purpose.

# File activestorage/app/models/active_storage/blob.rb, line 131
def text?
  content_type.start_with?("text")
end

Returns true if the content_type of this blob is in the text range, like text/plain.

# File activestorage/app/models/active_storage/blob.rb, line 170
def upload(io, identify: true)
  unfurl io, identify: identify
  upload_without_unfurling io
end

Uploads the io to the service on the key for this blob. Blobs are intended to be immutable, so you shouldn't be using this method after a file has already been uploaded to fit with a blob. If you want to create a derivative blob, you should instead simply create a new blob based on the old one.

Prior to uploading, we compute the checksum, which is sent to the service for transit integrity validation. If the checksum does not match what the service receives, an exception will be raised. We also measure the size of the io and store that in byte_size on the blob record. The content type is automatically extracted from the io unless you specify a content_type and pass identify as false.

Normally, you do not have to call this method directly at all. Use the factory class methods of build_after_upload and create_after_upload!.

# File activestorage/app/models/active_storage/blob.rb, line 126
def video?
  content_type.start_with?("video")
end

Returns true if the content_type of this blob is in the video range, like video/mp4.