shrine 2.6.1 → 2.7.0

data/lib/shrine/plugins/rack_file.rb

@@ -120,7 +120,7 @@ class Shrine
         end
 
         extend Forwardable
-        delegate Shrine::IO_METHODS.keys => :@tempfile
+        delegate [:read, :size, :rewind, :eof?, :close] => :@tempfile
       end
     end
 

data/lib/shrine/plugins/rack_response.rb

@@ -0,0 +1,85 @@
+require "rack"
+
+class Shrine
+  module Plugins
+    # The `rack_response` plugin allows you to convert an `UploadedFile` object
+    # into a triple consisting of status, headers, and body, suitable for
+    # returning as a response in a Rack-based application.
+    #
+    #     plugin :rack_response
+    #
+    # To convert a `Shrine::UploadedFile` into a Rack response, simply call
+    # `#to_rack_response`:
+    #
+    #     status, headers, body = uploaded_file.to_rack_response
+    #     status  #=> 200
+    #     headers #=> {"Content-Length" => "100", "Content-Type" => "text/plain", "Content-Disposition" => "inline; filename=\"file.txt\""}
+    #     body    # object that responds to #each and #close
+    #
+    # An example how this can be used in a Rails controller:
+    #
+    #     class FilesController < ActionController::Base
+    #       def download
+    #         # ...
+    #         file_response = record.attachment.to_rack_response
+    #
+    #         response.status = file_response[0]
+    #         response.headers.merge!(file_response[1])
+    #         self.response_body = file_response[2]
+    #       end
+    #     end
+    #
+    # By default the "Content-Disposition" header will use the `inline`
+    # disposition, but you can change it to `attachment` if you don't want the
+    # file to be rendered inside the browser:
+    #
+    #     status, headers, body = uploaded_file.to_rack_response(disposition: "attachment")
+    #     headers["Content-Disposition"] #=> "attachment; filename=\"file.txt\""
+    module RackResponse
+      module FileMethods
+        # Returns a Rack response triple for the uploaded file.
+        def to_rack_response(disposition: "inline")
+          status  = 200
+          headers = rack_headers(disposition: disposition)
+          body    = rack_body
+
+          [status, headers, body]
+        end
+
+        private
+
+        # Returns a hash of "Content-Length", "Content-Type", and
+        # "Content-Disposition" headers, whose values are extracted from
+        # metadata.
+        def rack_headers(disposition:)
+          length   = size || io.size
+          type     = mime_type || Rack::Mime.mime_type(".#{extension}")
+          filename = original_filename || id.split("/").last
+
+          headers = {}
+          headers["Content-Length"]      = length.to_s if length
+          headers["Content-Type"]        = type
+          headers["Content-Disposition"] = "#{disposition}; filename=\"#{filename}\""
+
+          headers
+        end
+
+        # Returns an object that responds to #each and #close, which yields
+        # contents of the file.
+        def rack_body
+          chunks = Enumerator.new do |yielder|
+            if io.respond_to?(:each_chunk) # Down::ChunkedIO
+              io.each_chunk { |chunk| yielder << chunk }
+            else
+              yielder << io.read(16*1024) until io.eof?
+            end
+          end
+
+          Rack::BodyProxy.new(chunks) { io.close }
+        end
+      end
+    end
+
+    register_plugin(:rack_response, RackResponse)
+  end
+end

data/lib/shrine/plugins/remote_url.rb

@@ -1,3 +1,5 @@
+require "down"
+
 class Shrine
   module Plugins
     # The `remote_url` plugin allows you to attach files from a remote location.
@@ -42,15 +44,12 @@ class Shrine
     #
     # If you want to customize how the file is downloaded, you can override the
     # `:downloader` parameter and provide your own implementation. For example,
-    # you can ensure the URL is URI-encoded (using the [Addressable] gem) before
-    # passing it to Down:
+    # you can use the HTTP.rb Down backend for downloading:
     #
-    #     require "down"
-    #     require "addressable/uri"
+    #     require "down/http"
     #
     #     plugin :remote_url, max_size: 20*1024*1024, downloader: ->(url, max_size:) do
-    #       url = Addressable::URI.encode(Addressable::URI.decode(url))
-    #       Down.download(url, max_size: max_size, max_redirects: 4, read_timeout: 3)
+    #       Down::Http.download(url, max_size: max_size, follow: { max_hops: 4 }, timeout: { read: 3 })
     #     end
     #
     # ## Errors
@@ -138,7 +137,6 @@ class Shrine
         # We silence any download errors, because for the user's point of view
         # the download simply failed.
         def download_with_open_uri(url, max_size:)
-          require "down"
           Down.download(url, max_size: max_size)
         end
 

data/lib/shrine/plugins/sequel.rb

@@ -74,7 +74,7 @@ class Shrine
             def validate
               super
               #{@name}_attacher.errors.each do |message|
-                errors.add(:#{@name}, message)
+                errors.add(:#{@name}, *message)
               end
             end
           RUBY

data/lib/shrine/plugins/signature.rb

@@ -133,7 +133,7 @@ class Shrine
 
         def encode_base64(hash)
           require "base64"
-          Base64.encode64(hash)
+          Base64.strict_encode64(hash)
         end
       end
 

data/lib/shrine/plugins/upload_endpoint.rb

@@ -0,0 +1,238 @@
+require "rack"
+
+require "json"
+
+class Shrine
+  module Plugins
+    # The `upload_endpoint` plugin provides a Rack endpoint which accepts file
+    # uploads and forwards them to specified storage. It can be used with
+    # client-side file upload libraries like [FineUploader], [Dropzone] or
+    # [jQuery-File-Upload] for asynchronous uploads.
+    #
+    #     plugin :upload_endpoint
+    #
+    # The plugin adds a `Shrine.upload_endpoint` method which accepts a storage
+    # identifier and returns a Rack application that accepts multipart POST
+    # requests, and uploads received files to the specified storage.
+    #
+    #     Shrine.upload_endpoint(:cache) # rack app
+    #
+    # Asynchronous upload is typically meant to replace the caching phase in
+    # the default synchronous workflow, so we want the uploads to go to
+    # temporary (`:cache`) storage.
+    #
+    # When we want to mount the Rack application to our app, it's recommended
+    # to generate endpoints for specific uploaders. This is because different
+    # uploaders may have different uploading logic, and this also allows
+    # customizing the upload endpoint per uploader.
+    #
+    #     Rails.application.routes.draw do
+    #       mount ImageUploader.upload_endpoint(:cache) => "/images/upload"
+    #     end
+    #
+    # The above will create a `POST /images/upload` endpoint, which uploads the
+    # file received in the `file` param using `ImageUploader`, and returns a
+    # JSON representation of the uploaded file.
+    #
+    #     # POST /images/upload
+    #     {
+    #       "id": "43kewit94.jpg",
+    #       "storage": "cache",
+    #       "metadata": {
+    #         "size": 384393,
+    #         "filename": "nature.jpg",
+    #         "mime_type": "image/jpeg"
+    #       }
+    #     }
+    #
+    # This JSON string can now be assigned to an attachment attribute instead
+    # of a raw file. In a form it can be written to a hidden attachment field,
+    # and then it can be assigned as the attachment.
+    #
+    # ## Limiting filesize
+    #
+    # It's good practice to limit the accepted filesize of uploaded files. You
+    # can do that with the `:max_size` option:
+    #
+    #     plugin :upload_endpoint, max_size: 20*1024*1024 # 20 MB
+    #
+    # If the uploaded file is larger than the specified value, a `413 Payload
+    # Too Large` response will be returned.
+    #
+    # ## Context
+    #
+    # The upload context will *not* contain `:record` and `:name` values, as
+    # the upload happens independently of a database record. The endpoint will
+    # sent the following upload context:
+    #
+    # * `:action` - holds the value `:upload`
+    # * `:request` - holds an instance of `Rack::Request`
+    #
+    # You can update the upload context via `:upload_context`:
+    #
+    #     plugin :upload_endpoint, upload_context: -> (request) do
+    #       { location: "my-location" }
+    #     end
+    #
+    # ## Upload
+    #
+    # You can also customize the upload itself via the `:upload` option:
+    #
+    #     plugin :upload_endpoint, upload: -> (io, context, request) do
+    #       # perform uploading and return the Shrine::UploadedFile
+    #     end
+    #
+    # ## Response
+    #
+    # The response returned by the endpoint can be customized via the
+    # `:rack_response` option:
+    #
+    #     plugin :upload_endpoint, rack_response: -> (uploaded_file, request) do
+    #       body = { data: uploaded_file.data, url: uploaded_file.url }.to_json
+    #       [201, { "Content-Type" => "application/json" }, [body]]
+    #     end
+    #
+    # ## Ad-hoc options
+    #
+    # You can override any of the options above when creating the endpoint:
+    #
+    #     Shrine.upload_endpoint(:cache, max_size: 20*1024*1024)
+    #
+    # [FineUploader]: https://github.com/FineUploader/fine-uploader
+    # [Dropzone]: https://github.com/enyo/dropzone
+    # [jQuery-File-Upload]: https://github.com/blueimp/jQuery-File-Upload
+    module UploadEndpoint
+      def self.load_dependencies(uploader, opts = {})
+        uploader.plugin :rack_file
+      end
+
+      def self.configure(uploader, opts = {})
+        uploader.opts[:upload_endpoint_max_size] = opts.fetch(:max_size, uploader.opts[:upload_endpoint_max_size])
+        uploader.opts[:upload_endpoint_upload_context] = opts.fetch(:upload_context, uploader.opts[:upload_endpoint_upload_context])
+        uploader.opts[:upload_endpoint_upload] = opts.fetch(:upload, uploader.opts[:upload_endpoint_upload])
+        uploader.opts[:upload_endpoint_rack_response] = opts.fetch(:rack_response, uploader.opts[:upload_endpoint_rack_response])
+      end
+
+      module ClassMethods
+        # Returns a Rack application (object that responds to `#call`) which
+        # accepts multipart POST requests to the root URL, uploads given file
+        # to the specified storage, and returns that information in JSON format.
+        #
+        # The `storage_key` needs to be one of the registered Shrine storages.
+        # Additional options can be given to override the options given on
+        # plugin initialization.
+        def upload_endpoint(storage_key, **options)
+          App.new({
+            shrine_class:   self,
+            storage_key:    storage_key,
+            max_size:       opts[:upload_endpoint_max_size],
+            upload_context: opts[:upload_endpoint_upload_context],
+            upload:         opts[:upload_endpoint_upload],
+            rack_response:  opts[:upload_endpoint_rack_response],
+          }.merge(options))
+        end
+      end
+
+      # Rack application that accepts multipart POSt request to the root URL,
+      # calls `#upload` with the uploaded file, and returns the uploaded file
+      # information in JSON format.
+      class App
+        # Writes given options to instance variables.
+        def initialize(options)
+          options.each do |name, value|
+            instance_variable_set("@#{name}", value)
+          end
+        end
+
+        # Accepts a Rack env hash, routes POST requests to the root URL, and
+        # returns a Rack response triple.
+        #
+        # If request isn't to the root URL, a `404 Not Found` response is
+        # returned. If request verb isn't GET, a `405 Method Not Allowed`
+        # response is returned.
+        def call(env)
+          request = Rack::Request.new(env)
+
+          status, headers, body = catch(:halt) do
+            error!(404, "Not Found") unless ["", "/"].include?(request.path_info)
+            error!(405, "Method Not Allowed") unless request.post?
+
+            handle_request(request)
+          end
+
+          headers["Content-Length"] = body.map(&:bytesize).inject(0, :+).to_s
+
+          [status, headers, body]
+        end
+
+        private
+
+        # Accepts a `Rack::Request` object, uploads the file, and returns a Rack
+        # response.
+        def handle_request(request)
+          io      = get_io(request)
+          context = get_context(request)
+
+          uploaded_file = upload(io, context, request)
+
+          make_response(uploaded_file, request)
+        end
+
+        # Retrieves the "file" multipart request parameter, and returns an
+        # IO-like object that can be passed to `Shrine#upload`.
+        def get_io(request)
+          file = request.params["file"]
+
+          error!(400, "Upload Not Found") unless file.is_a?(Hash) && file[:tempfile]
+          error!(413, "Upload Too Large") if @max_size && file[:tempfile].size > @max_size
+
+          @shrine_class.rack_file(file)
+        end
+
+        # Returns a hash of information containing `:action` and `:request`
+        # keys, which is to be passed to `Shrine#upload`. Calls
+        # `:upload_context` option if given.
+        def get_context(request)
+          context = { action: :upload, phase: :upload, request: request }
+          context.merge! @upload_context.call(request) if @upload_context
+          context
+        end
+
+        # Calls `Shrine#upload` with the given IO and context, and returns a
+        # `Shrine::UploadedFile` object. If `:upload` option is given, calls
+        # that instead.
+        def upload(io, context, request)
+          if @upload
+            @upload.call(io, context, request)
+          else
+            uploader.upload(io, context)
+          end
+        end
+
+        # Transforms the uploaded file object into a JSON response. It returns
+        # a Rack response triple - an array consisting of a status number, hash
+        # of headers, and a body enumerable. If a `:rack_response` option is
+        # given, calls that instead.
+        def make_response(object, request)
+          if @rack_response
+            @rack_response.call(object, request)
+          else
+            [200, {"Content-Type" => "application/json"}, [object.to_json]]
+          end
+        end
+
+        # Used for early returning an error response.
+        def error!(status, message)
+          throw :halt, [status, {"Content-Type" => "text/plain"}, [message]]
+        end
+
+        # Returns the uploader around the specified storage.
+        def uploader
+          @shrine_class.new(@storage_key)
+        end
+      end
+    end
+
+    register_plugin(:upload_endpoint, UploadEndpoint)
+  end
+end

data/lib/shrine/storage/file_system.rb

@@ -202,8 +202,9 @@ class Shrine
       def method_missing(name, *args)
         if name == :download
           Shrine.deprecation("Shrine::Storage::FileSystem#download is deprecated and will be removed in Shrine 3.")
-          require "down"
-          open(*args) { |file| Down.copy_to_tempfile(*args, file) }
+          tempfile = Tempfile.new(["shrine-filesystem", File.extname(args[0])], binmode: true)
+          open(*args) { |file| IO.copy_stream(file, tempfile) }
+          tempfile.tap(&:open)
         else
           super
         end

data/lib/shrine/storage/s3.rb

@@ -1,16 +1,22 @@
-require "aws-sdk"
-require "down"
+begin
+  require "aws-sdk-s3"
+  if Gem::Version.new(Aws::S3::GEM_VERSION) < Gem::Version.new("1.2.0")
+    raise "Shrine::Storage::S3 requires aws-sdk-s3 version 1.2.0 or above"
+  end
+rescue LoadError
+  require "aws-sdk"
+  Aws.eager_autoload!(services: ["S3"])
+end
+require "down/chunked_io"
 require "uri"
-require "cgi/util"
-
-Aws.eager_autoload!(services: ["S3"])
+require "cgi"
 
 class Shrine
   module Storage
-    # The S3 storage handles uploads to Amazon S3 service, using the [aws-sdk]
-    # gem:
+    # The S3 storage handles uploads to Amazon S3 service, using the
+    # [aws-sdk-s3] gem:
     #
-    #     gem "aws-sdk", "~> 2.1"
+    #     gem "aws-sdk-s3", "~> 1.2"
     #
     # It is initialized with the following 4 required options:
     #
@@ -49,7 +55,7 @@ class Shrine
     #
     #     Shrine::Storage::S3.new(upload_options: {acl: "private"}, **s3_options)
     #
-    # These options will be passed to aws-sdk's methods for [uploading],
+    # These options will be passed to aws-sdk-s3's methods for [uploading],
     # [copying] and [presigning].
     #
     # You can also generate upload options per upload with the `upload_options`
@@ -81,7 +87,7 @@ class Shrine
     #     uploaded_file.url(public: true)   # public URL without signed parameters
     #     uploaded_file.url(download: true) # forced download URL
     #
-    # All other options are forwarded to the [aws-sdk] gem:
+    # All other options are forwarded to the aws-sdk-s3 gem:
     #
     #     uploaded_file.url(expires_in: 15)
     #     uploaded_file.url(virtual_host: true)
@@ -106,16 +112,16 @@ class Shrine
     # ## Presigns
     #
     # This storage can generate presigns for direct uploads to Amazon S3, and
-    # it accepts additional options which are passed to [aws-sdk]. There are
+    # it accepts additional options which are passed to aws-sdk-s3. There are
     # three places in which you can specify presign options:
     #
     # * in `:upload_options` option on this storage
-    # * in `direct_upload` plugin through `:presign_options`
+    # * in `presign_endpoint` plugin through `:presign_options`
     # * in `Storage::S3#presign` by forwarding options
     #
     # ## Large files
     #
-    # The [aws-sdk] gem has the ability to automatically use multipart
+    # The aws-sdk-s3 gem has the ability to automatically use multipart
     # upload/copy for larger files, splitting the file into multiple chunks
     # and uploading/copying them in parallel.
     #
@@ -127,7 +133,7 @@ class Shrine
     #     thresholds = {upload: 30*1024*1024, copy: 200*1024*1024}
     #     Shrine::Storage::S3.new(multipart_threshold: thresholds, **s3_options)
     #
-    # If you want to change how many threads [aws-sdk] will use for multipart
+    # If you want to change how many threads aws-sdk-s3 will use for multipart
     # upload/copy, you can use the `upload_options` plugin to specify
     # `:thread_count`.
     #
@@ -139,14 +145,14 @@ class Shrine
     #
     # If you're using S3 as a cache, you will probably want to periodically
     # delete old files which aren't used anymore. S3 has a built-in way to do
-    # this, read [this article](http://docs.aws.amazon.com/AmazonS3/latest/UG/lifecycle-configuration-bucket-no-versioning.html)
-    # for instructions.
+    # this, read [this article][object lifecycle] for instructions.
     #
-    # [uploading]: http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Object.html#put-instance_method
-    # [copying]: http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Object.html#copy_from-instance_method
-    # [presigning]: http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Object.html#presigned_post-instance_method
-    # [aws-sdk]: https://github.com/aws/aws-sdk-ruby
+    # [uploading]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html#put-instance_method
+    # [copying]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html#copy_from-instance_method
+    # [presigning]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html#presigned_post-instance_method
+    # [aws-sdk-s3]: https://github.com/aws/aws-sdk-ruby/tree/master/gems/aws-sdk-s3
     # [Transfer Acceleration]: http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html
+    # [object lifecycle]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html#put-instance_method
     class S3
       attr_reader :client, :bucket, :prefix, :host, :upload_options
 
@@ -156,7 +162,7 @@ class Shrine
       # :secret_access_key
       # :region
       # :bucket
-      # :   Credentials required by the `aws-sdk` gem.
+      # :   Credentials required by the `aws-sdk-s3` gem.
       #
       # :prefix
       # :   "Folder" name inside the bucket to store files into.
@@ -174,22 +180,21 @@ class Shrine
       #
       # All other options are forwarded to [`Aws::S3::Client#initialize`].
       #
-      # [`Aws::S3::Object#put`]: http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Object.html#put-instance_method
-      # [`Aws::S3::Object#copy_from`]: http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Object.html#copy_from-instance_method
-      # [`Aws::S3::Bucket#presigned_post`]: http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Object.html#presigned_post-instance_method
-      # [`Aws::S3::Client#initialize`]: http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Client.html#initialize-instance_method
+      # [`Aws::S3::Object#put`]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html#put-instance_method
+      # [`Aws::S3::Object#copy_from`]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html#copy_from-instance_method
+      # [`Aws::S3::Bucket#presigned_post`]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html#presigned_post-instance_method
+      # [`Aws::S3::Client#initialize`]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#initialize-instance_method
       def initialize(bucket:, prefix: nil, host: nil, upload_options: {}, multipart_threshold: {}, **s3_options)
         Shrine.deprecation("The :host option to Shrine::Storage::S3#initialize is deprecated and will be removed in Shrine 3. Pass :host to S3#url instead, you can also use default_url_options plugin.") if host
         resource = Aws::S3::Resource.new(**s3_options)
 
         if multipart_threshold.is_a?(Integer)
           Shrine.deprecation("Accepting the :multipart_threshold S3 option as an integer is deprecated, use a hash with :upload and :copy keys instead, e.g. {upload: 15*1024*1024, copy: 150*1024*1024}")
-          multipart_threshold = {upload: multipart_threshold}
+          multipart_threshold = { upload: multipart_threshold }
         end
-        multipart_threshold[:upload] ||= 15*1024*1024
-        multipart_threshold[:copy]   ||= 100*1024*1024
+        multipart_threshold = { upload: 15*1024*1024, copy: 100*1024*1024 }.merge(multipart_threshold)
 
-        @bucket = resource.bucket(bucket)
+        @bucket = resource.bucket(bucket) or fail(ArgumentError, "the :bucket option was nil")
         @client = resource.client
         @prefix = prefix
         @host = host
@@ -240,7 +245,10 @@ class Shrine
 
       # Returns a `Down::ChunkedIO` object representing the S3 object.
       def open(id)
-        Down.open(url(id), ssl_ca_cert: Aws.config[:ssl_ca_bundle])
+        object = object(id)
+        io = Down::ChunkedIO.new(chunks: object.enum_for(:get), data: {object: object})
+        io.size = object.content_length
+        io
       end
 
       # Returns true file exists on S3.
@@ -248,20 +256,6 @@ class Shrine
         object(id).exists?
       end
 
-      # Deletes the file from S3.
-      def delete(id)
-        object(id).delete
-      end
-
-      # This is called when multiple files are being deleted at once. Issues a
-      # single MULTI DELETE command for each 1000 objects (S3 delete limit).
-      def multi_delete(ids)
-        ids.each_slice(1000) do |ids_batch|
-          delete_params = {objects: ids_batch.map { |id| {key: object(id).key} }}
-          bucket.delete_objects(delete: delete_params)
-        end
-      end
-
       # Returns the presigned URL to the file.
       #
       # :public
@@ -282,8 +276,8 @@ class Shrine
       # All other options are forwarded to [`Aws::S3::Object#presigned_url`] or
       # [`Aws::S3::Object#public_url`].
       #
-      # [`Aws::S3::Object#presigned_url`]: http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Object.html#presigned_url-instance_method
-      # [`Aws::S3::Object#public_url`]: http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Object.html#public_url-instance_method
+      # [`Aws::S3::Object#presigned_url`]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html#presigned_url-instance_method
+      # [`Aws::S3::Object#public_url`]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html#public_url-instance_method
       def url(id, download: nil, public: nil, host: self.host, **options)
         options[:response_content_disposition] ||= "attachment" if download
         options[:response_content_disposition] = encode_content_disposition(options[:response_content_disposition]) if options[:response_content_disposition]
@@ -303,24 +297,38 @@ class Shrine
         url
       end
 
-      # Deletes all files from the storage.
-      def clear!
-        objects = bucket.object_versions(prefix: prefix)
-        objects.respond_to?(:batch_delete!) ? objects.batch_delete! : objects.delete
-      end
-
       # Returns a signature for direct uploads. Internally it calls
       # [`Aws::S3::Bucket#presigned_post`], and forwards any additional options
       # to it.
       #
-      # [`Aws::S3::Bucket#presigned_post`]: http://docs.aws.amazon.com/sdkforruby/api/Aws/S3/Bucket.html#presigned_post-instance_method
+      # [`Aws::S3::Bucket#presigned_post`]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Bucket.html#presigned_post-instance_method
       def presign(id, **options)
-        options = upload_options.merge(options)
+        options = @upload_options.merge(options)
         options[:content_disposition] = encode_content_disposition(options[:content_disposition]) if options[:content_disposition]
 
         object(id).presigned_post(options)
       end
 
+      # Deletes the file from S3.
+      def delete(id)
+        object(id).delete
+      end
+
+      # This is called when multiple files are being deleted at once. Issues a
+      # single MULTI DELETE command for each 1000 objects (S3 delete limit).
+      def multi_delete(ids)
+        ids.each_slice(1000) do |ids_batch|
+          delete_params = {objects: ids_batch.map { |id| {key: object(id).key} }}
+          bucket.delete_objects(delete: delete_params)
+        end
+      end
+
+      # Deletes all files from the storage.
+      def clear!
+        objects = bucket.object_versions(prefix: prefix)
+        objects.respond_to?(:batch_delete!) ? objects.batch_delete! : objects.delete
+      end
+
       # Returns an `Aws::S3::Object` for the given id.
       def object(id)
         bucket.object([*prefix, id].join("/"))