shrine 3.6.0 → 3.7.0

data/lib/shrine/plugins/restore_cached_data.rb

@@ -11,14 +11,14 @@ class Shrine
       module AttacherMethods
         private
 
-        def cached(value, **options)
+        def cached(value, **)
           cached_file = super
 
           # TODO: Remove this conditional when we remove the versions plugin
           if cached_file.is_a?(Hash) || cached_file.is_a?(Array)
-            uploaded_file(cached_file) { |file| file.refresh_metadata!(**context, **options) }
+            uploaded_file(cached_file) { |file| file.refresh_metadata!(**context, **) }
           else
-            cached_file.refresh_metadata!(**context, **options)
+            cached_file.refresh_metadata!(**context, **)
           end
 
           cached_file

data/lib/shrine/plugins/signature.rb

@@ -37,7 +37,7 @@ class Shrine
         def instrument_signature(io, algorithm, format, &block)
           return yield unless respond_to?(:instrument)
 
-          instrument(:signature, io: io, algorithm: algorithm, format: format, &block)
+          instrument(:signature, io:, algorithm:, format:, &block)
         end
       end
 
@@ -45,7 +45,7 @@ class Shrine
         # Calculates `algorithm` hash of the contents of the IO object, and
         # encodes it into `format`.
         def calculate_signature(io, algorithm, format: :hex)
-          self.class.calculate_signature(io, algorithm, format: format)
+          self.class.calculate_signature(io, algorithm, format:)
         end
       end
 

data/lib/shrine/plugins/store_dimensions.rb

@@ -57,7 +57,7 @@ class Shrine
         def dimensions_analyzer(name)
           on_error = opts[:store_dimensions][:on_error]
 
-          DimensionsAnalyzer.new(name, on_error: on_error).method(:call)
+          DimensionsAnalyzer.new(name, on_error:).method(:call)
         end
 
         private
@@ -66,7 +66,7 @@ class Shrine
         def instrument_dimensions(io, &block)
           return yield unless respond_to?(:instrument)
 
-          instrument(:image_dimensions, io: io, &block)
+          instrument(:image_dimensions, io:, &block)
         end
       end
 

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

data/lib/shrine/plugins/upload_options.rb

@@ -15,7 +15,7 @@ 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)

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/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
@@ -123,7 +123,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 +175,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

@@ -68,10 +68,11 @@ 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: {}, max_multipart_parts: nil, signer: nil, public: nil, copy_options: COPY_OPTIONS, **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
@@ -97,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)
@@ -116,8 +116,8 @@ class Shrine
       # 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, encoding: nil, **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, encoding: encoding)
       rescue Aws::S3::Errors::NoSuchKey
@@ -145,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
@@ -159,7 +159,7 @@ class Shrine
         end
 
         if signer
-          url = signer.call(url, **options)
+          url = signer.call(url, **)
         end
 
         url
@@ -190,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
@@ -231,12 +230,21 @@ class Shrine
 
       private
 
-      # Uploads the file to S3. Uses multipart upload for large files.
-      def put(io, id, **options)
-        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|
+      # Upload the file to S3.
+      # Uses @transfer_manager, if defined, for any size upload.
+      # Falls back to the original code using the older, now depricated
+      # AWS APIs for users of older version of the AWS Gem.
+      # for multipart uploads of large files.
+      def put(io, id, **)
+        if @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
+        elsif io.respond_to?(:size) && io.size && io.size <= @multipart_threshold[:upload]
+          object(id).put(body: io, **)
+        else
+          # multipart upload old API
+          object(id).upload_stream(part_size: part_size(io), **) do |write_stream|
             IO.copy_stream(io, write_stream)
           end
         end
@@ -255,8 +263,7 @@ class Shrine
           options.merge!(multipart_copy: true, content_length: io.size)
         end
 
-        options.merge!(@copy_options)
-        options.merge!(copy_options)
+        options.merge!(@copy_options, copy_options)
 
         object(id).copy_from(io.storage.object(io.id), **options)
       end
@@ -274,13 +281,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
@@ -301,8 +309,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"])
@@ -315,8 +323,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
@@ -359,10 +367,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
 
@@ -370,19 +378,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|

data/lib/shrine/uploaded_file.rb

@@ -22,6 +22,8 @@ class Shrine
     end
 
     module InstanceMethods
+      RFC2396_PARSER = URI::RFC2396_Parser.new
+
       # The location where the file was uploaded to the storage.
       attr_reader :id
 
@@ -50,7 +52,7 @@ class Shrine
       # The extension derived from #id if present, otherwise it's derived
       # from #original_filename.
       def extension
-        identifier = id =~ URI::DEFAULT_PARSER.make_regexp ? id.sub(/\?.+$/, "") : id # strip query params for shrine-url
+        identifier = id =~ RFC2396_PARSER.make_regexp ? id.sub(/\?.+$/, "") : id # strip query params for shrine-url
         result = File.extname(identifier)[1..-1]
         result ||= File.extname(original_filename.to_s)[1..-1]
         result.downcase if result
@@ -89,9 +91,9 @@ class Shrine
       #     # or
       #
       #     uploaded_file.open { |io| io.read } # the IO is automatically closed
-      def open(**options)
+      def open(**)
         @io.close if @io
-        @io = _open(**options)
+        @io = _open(**)
 
         return @io unless block_given?
 
@@ -118,9 +120,9 @@ class Shrine
       #     # or
       #
       #     uploaded_file.download { |tempfile| tempfile.read } # tempfile is deleted
-      def download(**options)
+      def download(**)
         tempfile = Tempfile.new(["shrine", ".#{extension}"], binmode: true)
-        stream(tempfile, **options)
+        stream(tempfile, **)
         tempfile.open
 
         block_given? ? yield(tempfile) : tempfile
@@ -139,19 +141,19 @@ class Shrine
       #     uploaded_file.stream(StringIO.new)
       #     # or
       #     uploaded_file.stream("/path/to/destination")
-      def stream(destination, **options)
+      def stream(destination, **)
         if opened?
           IO.copy_stream(io, destination)
           io.rewind
         else
-          open(**options) { |io| IO.copy_stream(io, destination) }
+          open(**) { |io| IO.copy_stream(io, destination) }
         end
       end
 
       # Part of complying to the IO interface. It delegates to the internally
       # opened IO object.
-      def read(*args)
-        io.read(*args)
+      def read(*)
+        io.read(*)
       end
 
       # Part of complying to the IO interface. It delegates to the internally
@@ -179,8 +181,8 @@ class Shrine
       end
 
       # Calls `#url` on the storage, forwarding any given URL options.
-      def url(**options)
-        storage.url(id, **options)
+      def url(**)
+        storage.url(id, **)
       end
 
       # Calls `#exists?` on the storage, which checks whether the file exists
@@ -190,8 +192,8 @@ class Shrine
       end
 
       # Uploads a new file to this file's location and returns it.
-      def replace(io, **options)
-        uploader.upload(io, **options, location: id)
+      def replace(io, **)
+        uploader.upload(io, **, location: id)
       end
 
       # Calls `#delete` on the storage, which deletes the file from the
@@ -207,12 +209,12 @@ class Shrine
 
       # Returns the data hash in the JSON format. Suitable for storing in a
       # database column or passing to a background job.
-      def to_json(*args)
-        data.to_json(*args)
+      def to_json(*)
+        data.to_json(*)
       end
 
       # Conform to ActiveSupport's JSON interface.
-      def as_json(*args)
+      def as_json(*)
         data
       end
 
@@ -263,8 +265,8 @@ class Shrine
         @io ||= _open
       end
 
-      def _open(**options)
-        storage.open(id, **options)
+      def _open(**)
+        storage.open(id, **)
       end
     end
 

data/lib/shrine/version.rb

@@ -7,7 +7,7 @@ class Shrine
 
   module VERSION
     MAJOR = 3
-    MINOR = 6
+    MINOR = 7
     TINY  = 0
     PRE   = nil