shrine 3.4.0 → 3.10.0

data/lib/shrine/plugins/upload_endpoint.rb

@@ -26,12 +26,12 @@ class Shrine
         # 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)
+        def upload_endpoint(storage_key, **)
           Shrine::UploadEndpoint.new(
             shrine_class: self,
             storage_key:  storage_key,
             **opts[:upload_endpoint],
-            **options,
+            **,
           )
         end
 
@@ -41,7 +41,7 @@ class Shrine
         # It performs the same mounting logic that Rack and other web
         # frameworks use, and is meant for cases where statically mounting the
         # endpoint in the router isn't enough.
-        def upload_response(storage_key, env, **options)
+        def upload_response(storage_key, env, **)
           script_name = env["SCRIPT_NAME"]
           path_info   = env["PATH_INFO"]
 
@@ -49,7 +49,7 @@ class Shrine
             env["SCRIPT_NAME"] += path_info
             env["PATH_INFO"]    = ""
 
-            upload_endpoint(storage_key, **options).call(env)
+            upload_endpoint(storage_key, **).call(env)
           ensure
             env["SCRIPT_NAME"] = script_name
             env["PATH_INFO"]   = path_info
@@ -91,7 +91,9 @@ class Shrine
         handle_request(request)
       end
 
-      headers["Content-Length"] ||= body.map(&:bytesize).inject(0, :+).to_s
+      headers = Rack::Headers[headers] if Rack.release >= "3"
+      headers["Content-Length"] ||= body.respond_to?(:bytesize) ? body.bytesize.to_s :
+                                                                  body.map(&:bytesize).inject(0, :+).to_s
 
       [status, headers, body]
     end

data/lib/shrine/plugins/upload_options.rb

@@ -4,9 +4,9 @@ class Shrine
   module Plugins
     # Documentation can be found on https://shrinerb.com/docs/plugins/upload_options
     module UploadOptions
-      def self.configure(uploader, **opts)
+      def self.configure(uploader, options = {})
         uploader.opts[:upload_options] ||= {}
-        uploader.opts[:upload_options].merge!(opts)
+        uploader.opts[:upload_options].merge!(options)
       end
 
       module InstanceMethods
@@ -15,15 +15,29 @@ class Shrine
         def _upload(io, **options)
           upload_options = get_upload_options(io, options)
 
-          super(io, **options, upload_options: upload_options)
+          super(io, **options, upload_options:)
         end
 
         def get_upload_options(io, options)
-          upload_options = opts[:upload_options][storage_key] || {}
+          upload_options = find_upload_options || {}
           upload_options = upload_options.call(io, options) if upload_options.respond_to?(:call)
           upload_options = upload_options.merge(options[:upload_options]) if options[:upload_options]
           upload_options
         end
+
+        # Matches the storage key exactly first, then falls back to any
+        # registered regex that matches the storage key. The regex form is
+        # useful when storage keys are generated dynamically (e.g. via the
+        # `dynamic_storage` plugin), since it's not possible to list every
+        # storage key upfront.
+        def find_upload_options
+          upload_options = opts[:upload_options]
+
+          return upload_options[storage_key] if upload_options.key?(storage_key)
+
+          _, options = upload_options.find { |key, _| key.is_a?(Regexp) && key.match?(storage_key.to_s) }
+          options
+        end
       end
     end
 

data/lib/shrine/plugins/url_options.rb

@@ -4,9 +4,9 @@ class Shrine
   module Plugins
     # Documentation can be found on https://shrinerb.com/docs/plugins/url_options
     module UrlOptions
-      def self.configure(uploader, **opts)
+      def self.configure(uploader, options = {})
         uploader.opts[:url_options] ||= {}
-        uploader.opts[:url_options].merge!(opts)
+        uploader.opts[:url_options].merge!(options)
       end
 
       module FileMethods
@@ -19,10 +19,24 @@ class Shrine
         private
 
         def url_options(options)
-          default_options = shrine_class.opts[:url_options][storage_key]
+          default_options = find_url_options
           default_options = default_options.call(self, options) if default_options.respond_to?(:call)
           default_options || {}
         end
+
+        # Matches the storage key exactly first, then falls back to any
+        # registered regex that matches the storage key. The regex form is
+        # useful when storage keys are generated dynamically (e.g. via the
+        # `dynamic_storage` plugin), since it's not possible to list every
+        # storage key upfront.
+        def find_url_options
+          url_options = shrine_class.opts[:url_options]
+
+          return url_options[storage_key] if url_options.key?(storage_key)
+
+          _, options = url_options.find { |key, _| key.is_a?(Regexp) && key.match?(storage_key.to_s) }
+          options
+        end
       end
     end
 

data/lib/shrine/plugins/validation.rb

@@ -24,21 +24,21 @@ class Shrine
         attr_reader :errors
 
         # Initializes validation errors to an empty array.
-        def initialize(**options)
+        def initialize(**)
           super
           @errors = []
         end
 
         # Performs validations after attaching cached file.
-        def attach_cached(value, validate: nil, **options)
-          result = super(value, validate: false, **options)
+        def attach_cached(value, validate: nil, **)
+          result = super(value, validate: false, **)
           validation(validate)
           result
         end
 
         # Performs validations after attaching file.
-        def attach(io, validate: nil, **options)
-          result = super(io, **options)
+        def attach(io, validate: nil, **)
+          result = super(io, **)
           validation(validate)
           result
         end
@@ -61,16 +61,16 @@ class Shrine
         end
 
         # Calls #validate_block, passing it accepted parameters.
-        def _validate(**options)
+        def _validate(**)
           if method(:validate_block).arity.zero?
             validate_block
           else
-            validate_block(**options)
+            validate_block(**)
           end
         end
 
         # Overridden by the `Attacher.validate` block.
-        def validate_block(**options)
+        def validate_block(**)
         end
       end
     end

data/lib/shrine/plugins/validation_helpers.rb

@@ -32,7 +32,7 @@ class Shrine
         "%.1f %s" % [bytes.to_f / 1024 ** exp, FILESIZE_UNITS[exp]]
       end
 
-      def self.load_dependencies(uploader, *)
+      def self.load_dependencies(uploader, **)
         uploader.plugin :validation
       end
 
@@ -145,7 +145,7 @@ class Shrine
 
         # Validates that the dimensions are not smaller than specified.
         #
-        #     validate_max_dimensions [100, 100]
+        #     validate_min_dimensions [100, 100]
         def validate_min_dimensions((min_width, min_height), message: nil)
           fail Error, "width and/or height metadata is missing" unless file["width"] && file["height"]
 

data/lib/shrine/plugins/versions.rb

@@ -59,16 +59,16 @@ class Shrine
 
         # Smart versioned URLs, which include the version name in the default
         # URL, and properly forwards any options to the underlying storage.
-        def url(version = nil, **options)
+        def url(version = nil, **)
           if file.is_a?(Hash)
             if version
               version = version.to_sym
               if file.key?(version)
-                file[version].url(**options)
+                file[version].url(**)
               elsif fallback = shrine_class.version_fallbacks[version]
-                url(fallback, **options)
+                url(fallback, **)
               else
-                default_url(**options, version: version)
+                default_url(**, version:)
               end
             else
               raise Error, "must call Shrine::Attacher#url with the name of the version"
@@ -76,12 +76,12 @@ class Shrine
           else
             if version
               if file && shrine_class.opts[:versions][:fallback_to_original]
-                file.url(**options)
+                file.url(**)
               else
-                default_url(**options, version: version)
+                default_url(**, version:)
               end
             else
-              super(**options)
+              super(**)
             end
           end
         end
@@ -130,7 +130,7 @@ class Shrine
 
         def map_file(object, transform_keys: :to_sym)
           if object.is_a?(Hash) || object.is_a?(Array)
-            deep_map(object, transform_keys: transform_keys) do |path, value|
+            deep_map(object, transform_keys:) do |path, value|
               yield path, value unless value.is_a?(Hash) || value.is_a?(Array)
             end
           elsif object
@@ -150,7 +150,7 @@ class Shrine
               key    = key.send(transform_keys)
               result = yield [*path, key], value
 
-              hash.merge! key => (result || deep_map(value, [*path, key], transform_keys: transform_keys, &block))
+              hash.merge! key => (result || deep_map(value, [*path, key], transform_keys:, &block))
             end
           elsif object.is_a?(Array)
             result = yield path, object
@@ -160,7 +160,7 @@ class Shrine
             object.map.with_index do |value, idx|
               result = yield [*path, idx], value
 
-              result || deep_map(value, [*path, idx], transform_keys: transform_keys, &block)
+              result || deep_map(value, [*path, idx], transform_keys:, &block)
             end
           else
             result = yield path, object

data/lib/shrine/plugins.rb

@@ -18,26 +18,18 @@ class Shrine
       plugin
     end
 
-    # Delegate call to the plugin in a way that works across Ruby versions.
-    def self.load_dependencies(plugin, uploader, *args, **kwargs, &block)
+    # Delegate to the plugin's `load_dependencies` method.
+    def self.load_dependencies(plugin, uploader, ...)
       return unless plugin.respond_to?(:load_dependencies)
 
-      if kwargs.any?
-        plugin.load_dependencies(uploader, *args, **kwargs, &block)
-      else
-        plugin.load_dependencies(uploader, *args, &block)
-      end
+      plugin.load_dependencies(uploader, ...)
     end
 
-    # Delegate call to the plugin in a way that works across Ruby versions.
-    def self.configure(plugin, uploader, *args, **kwargs, &block)
+    # Delegate to the plugin's `load_dependencies` method.
+    def self.configure(plugin, uploader, ...)
       return unless plugin.respond_to?(:configure)
 
-      if kwargs.any?
-        plugin.configure(uploader, *args, **kwargs, &block)
-      else
-        plugin.configure(uploader, *args, &block)
-      end
+      plugin.configure(uploader, ...)
     end
 
     # Register the given plugin with Shrine, so that it can be loaded using

data/lib/shrine/storage/file_system.rb

@@ -59,8 +59,8 @@ class Shrine
 
       # Opens the file on the given location in read mode. Accepts additional
       # `File.open` arguments.
-      def open(id, **options)
-        path(id).open(binmode: true, **options)
+      def open(id, **)
+        path(id).open(binmode: true, **)
       rescue Errno::ENOENT
         raise Shrine::FileNotFound, "file #{id.inspect} not found on storage"
       end
@@ -75,7 +75,7 @@ class Shrine
       # from the returned path (e.g. #directory can be set to "public" folder).
       # Both cases accept a `:host` value which will be prefixed to the
       # generated path.
-      def url(id, host: nil, **options)
+      def url(id, host: nil, **)
         path = (prefix ? relative_path(id) : path(id)).to_s
         host ? host + path : path
       end
@@ -113,9 +113,18 @@ class Shrine
         end
       end
 
-      # Returns the full path to the file.
+      # Returns the full path to the file. Raises Shrine::Error if the id would
+      # resolve to a location outside of the storage #directory (e.g. an id
+      # containing `../` path traversal sequences in attacker-controlled data).
       def path(id)
-        directory.join(id.gsub("/", File::SEPARATOR))
+        path = directory.join(id.gsub("/", File::SEPARATOR))
+        expanded = path.expand_path
+
+        unless expanded == directory || expanded.to_s.start_with?("#{directory}#{File::SEPARATOR}")
+          raise Shrine::Error, "path #{id.inspect} resolves outside of the storage directory"
+        end
+
+        path
       end
 
       protected
@@ -123,7 +132,7 @@ class Shrine
       # Cleans all empty subdirectories up the hierarchy.
       def clean(path)
         path.dirname.ascend do |pathname|
-          if dir_empty?(pathname) && pathname != directory
+          if Dir.empty?(pathname) && pathname != directory
             pathname.rmdir
           else
             break
@@ -175,19 +184,6 @@ class Shrine
           .find
           .each { |path| yield path if path.file? }
       end
-
-      if RUBY_VERSION >= "2.4"
-        def dir_empty?(path)
-          Dir.empty?(path)
-        end
-      else
-        # :nocov:
-        def dir_empty?(path)
-          Dir.foreach(path) { |x| return false unless [".", ".."].include?(x) }
-          true
-        end
-        # :nocov:
-      end
     end
   end
 end

data/lib/shrine/storage/linter.rb

@@ -24,18 +24,18 @@ class Shrine
     #
     #   Shrine::Storage::Linter.new(storage).call(->{File.open("test/fixtures/image.jpg")})
     class Linter
-      def self.call(*args)
-        new(*args).call
+      def self.call(*)
+        new(*).call
       end
 
-      def initialize(storage, action: :error, nonexisting: "nonexisting")
+      def initialize(storage, action: :error, nonexisting: String.new("nonexisting"))
         @storage     = storage
         @action      = action
         @nonexisting = nonexisting
       end
 
       def call(io_factory = default_io_factory)
-        storage.upload(io_factory.call, id = "foo", shrine_metadata: { "foo" => "bar" })
+        storage.upload(io_factory.call, id = String.new("foo"), shrine_metadata: { "foo" => "bar" })
 
         lint_open(id)
         lint_exists(id)
@@ -43,9 +43,9 @@ class Shrine
         lint_delete(id)
 
         if storage.respond_to?(:delete_prefixed)
-          storage.upload(io_factory.call, id1 = "a/a/a")
-          storage.upload(io_factory.call, id2 = "a/a/b")
-          storage.upload(io_factory.call, id3 = "a/aaa/a")
+          storage.upload(io_factory.call, id1 = String.new("a/a/a"))
+          storage.upload(io_factory.call, id2 = String.new("a/a/b"))
+          storage.upload(io_factory.call, id3 = String.new("a/aaa/a"))
 
           lint_delete_prefixed(prefix: "a/a/",
                                expect_deleted: [id1, id2],
@@ -55,7 +55,7 @@ class Shrine
         end
 
         if storage.respond_to?(:clear!)
-          storage.upload(io_factory.call, id = "quux".dup)
+          storage.upload(io_factory.call, id = String.new("quux"))
           lint_clear(id)
         end
 

data/lib/shrine/storage/memory.rb

@@ -17,9 +17,7 @@ class Shrine
       end
 
       def open(id, **)
-        io = StringIO.new(store.fetch(id))
-        io.set_encoding(io.string.encoding) # Ruby 2.7.0 – https://bugs.ruby-lang.org/issues/16497
-        io
+        StringIO.new(store.fetch(id))
       rescue KeyError
         raise Shrine::FileNotFound, "file #{id.inspect} not found on storage"
       end

data/lib/shrine/storage/s3.rb

@@ -14,13 +14,15 @@ require "tempfile"
 class Shrine
   module Storage
     class S3
-      attr_reader :client, :bucket, :prefix, :upload_options, :signer, :public
+      attr_reader :client, :bucket, :prefix, :upload_options, :copy_options, :signer, :public
 
       MAX_MULTIPART_PARTS = 10_000
       MIN_PART_SIZE       = 5*1024*1024
 
       MULTIPART_THRESHOLD = { upload: 15*1024*1024, copy: 100*1024*1024 }
 
+      COPY_OPTIONS = { tagging_directive: "REPLACE" }
+
       # Initializes a storage for uploading to S3. All options are forwarded to
       # [`Aws::S3::Client#initialize`], except the following:
       #
@@ -41,12 +43,20 @@ class Shrine
       #   be passed to [`Aws::S3::Object#put`], [`Aws::S3::Object#copy_from`]
       #   and [`Aws::S3::Bucket#presigned_post`].
       #
+      # :copy_options
+      # : Additional options that will be used for copying files, they will
+      #   be passed to [`Aws::S3::Object#copy_from`].
+      #
       # :multipart_threshold
       # : If the input file is larger than the specified size, a parallelized
       #   multipart will be used for the upload/copy. Defaults to
       #   `{upload: 15*1024*1024, copy: 100*1024*1024}` (15MB for upload
       #   requests, 100MB for copy requests).
       #
+      # :max_multipart_parts
+      # : Limits the number of parts if parellized multipart upload/copy is used.
+      # Defaults to 10_000.
+      #
       # In addition to specifying the `:bucket`, you'll also need to provide
       # AWS credentials. The most common way is to provide them directly via
       # `:access_key_id`, `:secret_access_key`, and `:region` options. But you
@@ -58,14 +68,17 @@ class Shrine
       # [`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
       # [configuring AWS SDK]: https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/setup-config.html
-      def initialize(bucket:, client: nil, prefix: nil, upload_options: {}, multipart_threshold: {}, signer: nil, public: nil, **s3_options)
+      def initialize(bucket:, client: nil, prefix: nil, upload_options: {}, multipart_threshold: {}, max_multipart_parts: nil, signer: nil, public: nil, copy_options: COPY_OPTIONS, **)
         raise ArgumentError, "the :bucket option is nil" unless bucket
 
-        @client = client || Aws::S3::Client.new(**s3_options)
+        @client = client || Aws::S3::Client.new(**)
+        @transfer_manager = Aws::S3::TransferManager.new(client: @client) if defined?(Aws::S3::TransferManager)
         @bucket = Aws::S3::Bucket.new(name: bucket, client: @client)
         @prefix = prefix
         @upload_options = upload_options
+        @copy_options = copy_options
         @multipart_threshold = MULTIPART_THRESHOLD.merge(multipart_threshold)
+        @max_multipart_parts = max_multipart_parts || MAX_MULTIPART_PARTS
         @signer = signer
         @public = public
       end
@@ -85,8 +98,7 @@ class Shrine
         options[:content_disposition] = ContentDisposition.inline(filename) if filename
         options[:acl] = "public-read" if public
 
-        options.merge!(@upload_options)
-        options.merge!(upload_options)
+        options.merge!(@upload_options, upload_options)
 
         if copyable?(io)
           copy(io, id, **options)
@@ -98,15 +110,16 @@ class Shrine
       # Returns a `Down::ChunkedIO` object that downloads S3 object content
       # on-demand. By default, read content will be cached onto disk so that
       # it can be rewinded, but if you don't need that you can pass
-      # `rewindable: false`.
+      # `rewindable: false`. A required character encoding can be passed in
+      # `encoding`; the default is `Encoding::BINARY` via `Down::ChunkedIO`.
       #
       # Any additional options are forwarded to [`Aws::S3::Object#get`].
       #
       # [`Aws::S3::Object#get`]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html#get-instance_method
-      def open(id, rewindable: true, **options)
-        chunks, length = get(id, **options)
+      def open(id, rewindable: true, encoding: nil, **)
+        chunks, length = get(id, **)
 
-        Down::ChunkedIO.new(chunks: chunks, rewindable: rewindable, size: length)
+        Down::ChunkedIO.new(chunks: chunks, rewindable: rewindable, size: length, encoding: encoding)
       rescue Aws::S3::Errors::NoSuchKey
         raise Shrine::FileNotFound, "file #{id.inspect} not found on storage"
       end
@@ -132,11 +145,11 @@ class Shrine
       #
       # [`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, public: self.public, host: nil, **options)
+      def url(id, public: self.public, host: nil, **)
         if public || signer
-          url = object(id).public_url(**options)
+          url = object(id).public_url(**)
         else
-          url = object(id).presigned_url(:get, **options)
+          url = object(id).presigned_url(:get, **)
         end
 
         if host
@@ -146,7 +159,7 @@ class Shrine
         end
 
         if signer
-          url = signer.call(url, **options)
+          url = signer.call(url, **)
         end
 
         url
@@ -177,8 +190,7 @@ class Shrine
         options = {}
         options[:acl] = "public-read" if public
 
-        options.merge!(@upload_options)
-        options.merge!(presign_options)
+        options.merge!(@upload_options, presign_options)
 
         send(:"presign_#{method}", id, options)
       end
@@ -219,11 +231,15 @@ class Shrine
       private
 
       # Uploads the file to S3. Uses multipart upload for large files.
-      def put(io, id, **options)
+      def put(io, id, **)
         if io.respond_to?(:size) && io.size && io.size <= @multipart_threshold[:upload]
-          object(id).put(body: io, **options)
-        else # multipart upload
-          object(id).upload_stream(part_size: part_size(io), **options) do |write_stream|
+          object(id).put(body: io, **)
+        elsif @transfer_manager # multipart upload - transfer manager
+          @transfer_manager.upload_stream(bucket: bucket.name, key: object_key(id), part_size: part_size(io), **) do |write_stream|
+            IO.copy_stream(io, write_stream)
+          end
+        else # multipart upload - before transfer manager
+          object(id).upload_stream(part_size: part_size(io), **) do |write_stream|
             IO.copy_stream(io, write_stream)
           end
         end
@@ -232,14 +248,17 @@ class Shrine
       # Copies an existing S3 object to a new location. Uses multipart copy for
       # large files.
       def copy(io, id, **copy_options)
-        options = { metadata_directive: "REPLACE" } # don't inherit source object metadata
+        # don't inherit source object metadata or AWS tags
+        options = {
+          metadata_directive: "REPLACE",
+        }
 
         if io.size && io.size >= @multipart_threshold[:copy]
           # pass :content_length on multipart copy to avoid an additional HEAD request
           options.merge!(multipart_copy: true, content_length: io.size)
         end
 
-        options.merge!(copy_options)
+        options.merge!(@copy_options, copy_options)
 
         object(id).copy_from(io.storage.object(io.id), **options)
       end
@@ -257,13 +276,14 @@ class Shrine
 
         # When any of these options are specified, the corresponding request
         # headers must be included in the upload request.
-        headers = {}
-        headers["Content-Length"]      = options[:content_length]      if options[:content_length]
-        headers["Content-Type"]        = options[:content_type]        if options[:content_type]
-        headers["Content-Disposition"] = options[:content_disposition] if options[:content_disposition]
-        headers["Content-Encoding"]    = options[:content_encoding]    if options[:content_encoding]
-        headers["Content-Language"]    = options[:content_language]    if options[:content_language]
-        headers["Content-MD5"]         = options[:content_md5]         if options[:content_md5]
+        headers = {
+          "Content-Length"      => options[:content_length],
+          "Content-Type"        => options[:content_type],
+          "Content-Disposition" => options[:content_disposition],
+          "Content-Encoding"    => options[:content_encoding],
+          "Content-Language"    => options[:content_language],
+          "Content-MD5"         => options[:content_md5],
+        }.compact
 
         { method: :put, url: url, headers: headers }
       end
@@ -273,10 +293,10 @@ class Shrine
       def part_size(io)
         return unless io.respond_to?(:size) && io.size
 
-        if io.size <= MIN_PART_SIZE * MAX_MULTIPART_PARTS # <= 50 GB
+        if io.size <= MIN_PART_SIZE * @max_multipart_parts # <= 50 GB
           MIN_PART_SIZE
         else # > 50 GB
-          (io.size.to_f / MAX_MULTIPART_PARTS).ceil
+          (io.size.to_f / @max_multipart_parts).ceil
         end
       end
 
@@ -284,8 +304,8 @@ class Shrine
       # object before all content is downloaded, so we hack our way around it.
       # This way get the content length without an additional HEAD request.
       if Gem::Version.new(Aws::CORE_GEM_VERSION) >= Gem::Version.new("3.104.0")
-        def get(id, **params)
-          enum = object(id).enum_for(:get, **params)
+        def get(id, **)
+          enum = object(id).enum_for(:get, **)
 
           begin
             content_length = Integer(enum.peek.last["content-length"])
@@ -298,8 +318,8 @@ class Shrine
           [chunks, content_length]
         end
       else
-        def get(id, **params)
-          req = client.build_request(:get_object, bucket: bucket.name, key: object_key(id), **params)
+        def get(id, **)
+          req = client.build_request(:get_object, bucket: bucket.name, key: object_key(id), **)
 
           body = req.enum_for(:send_request)
           begin
@@ -342,10 +362,10 @@ class Shrine
 
         # Save the encryption client and continue initialization with normal
         # client.
-        def initialize(client: nil, **options)
+        def initialize(client: nil, **)
           return super unless client.class.name.start_with?("Aws::S3::Encryption")
 
-          super(client: client.client, **options)
+          super(client: client.client, **)
           @encryption_client = client
         end
 
@@ -353,19 +373,19 @@ class Shrine
 
         # Encryption client doesn't support multipart uploads, so we always use
         # #put_object.
-        def put(io, id, **options)
+        def put(io, id, **)
           return super unless encryption_client
 
-          encryption_client.put_object(body: io, bucket: bucket.name, key: object_key(id), **options)
+          encryption_client.put_object(body: io, bucket: bucket.name, key: object_key(id), **)
         end
 
-        def get(id, **options)
+        def get(id, **)
           return super unless encryption_client
 
           # Encryption client v2 warns against streaming download, so we first
           # download all content into a file.
           tempfile = Tempfile.new("shrine-s3", binmode: true)
-          response = encryption_client.get_object(response_target: tempfile, bucket: bucket.name, key: object_key(id), **options)
+          response = encryption_client.get_object(response_target: tempfile, bucket: bucket.name, key: object_key(id), **)
           tempfile.rewind
 
           chunks = Enumerator.new do |yielder|