shrine 3.0.0 → 3.2.2

data/lib/shrine/plugins/signature.rb

@@ -21,10 +21,13 @@ class Shrine
       module ClassMethods
         # Calculates `algorithm` hash of the contents of the IO object, and
         # encodes it into `format`.
-        def calculate_signature(io, algorithm, format: :hex)
-          instrument_signature(io, algorithm, format) do
-            SignatureCalculator.new(algorithm.downcase, format: format).call(io)
-          end
+        def calculate_signature(io, algorithm, format: :hex, rewind: true)
+          calculator = SignatureCalculator.new(algorithm.downcase, format: format)
+
+          signature = instrument_signature(io, algorithm, format) { calculator.call(io) }
+          io.rewind if rewind
+
+          signature
         end
         alias signature calculate_signature
 
@@ -62,8 +65,6 @@ class Shrine
 
         def call(io)
           hash = send(:"calculate_#{algorithm}", io)
-          io.rewind
-
           send(:"encode_#{format}", hash)
         end
 

data/lib/shrine/plugins/store_dimensions.rb

@@ -113,23 +113,32 @@ class Shrine
 
         def extract_with_fastimage(io)
           require "fastimage"
-          FastImage.size(io, raise_on_failure: true)
-        rescue FastImage::FastImageException => error
-          on_error(error)
+
+          begin
+            FastImage.size(io, raise_on_failure: true)
+          rescue FastImage::FastImageException => error
+            on_error(error)
+          end
         end
 
         def extract_with_mini_magick(io)
           require "mini_magick"
-          Shrine.with_file(io) { |file| MiniMagick::Image.new(file.path).dimensions }
-        rescue MiniMagick::Error => error
-          on_error(error)
+
+          begin
+            Shrine.with_file(io) { |file| MiniMagick::Image.new(file.path).dimensions }
+          rescue MiniMagick::Error => error
+            on_error(error)
+          end
         end
 
         def extract_with_ruby_vips(io)
           require "vips"
-          Shrine.with_file(io) { |file| Vips::Image.new_from_file(file.path).size }
-        rescue Vips::Error => error
-          on_error(error)
+
+          begin
+            Shrine.with_file(io) { |file| Vips::Image.new_from_file(file.path).size }
+          rescue Vips::Error => error
+            on_error(error)
+          end
         end
 
         def on_error(error)

data/lib/shrine/plugins/type_predicates.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # Documentation can be found on https://shrinerb.com/docs/plugins/type_predicates
+    module TypePredicates
+      def self.configure(uploader, methods: [], **opts)
+        uploader.opts[:type_predicates] ||= { mime: :mini_mime }
+        uploader.opts[:type_predicates].merge!(opts)
+
+        methods.each do |name|
+          uploader::UploadedFile.send(:define_method, "#{name}?") { type?(name) }
+        end
+      end
+
+      module ClassMethods
+        def type_lookup(extension, database = nil)
+          database ||= opts[:type_predicates][:mime]
+          database   = MimeDatabase.new(database) if database.is_a?(Symbol)
+          database.call(extension.to_s)
+        end
+      end
+
+      module FileMethods
+        def image?
+          general_type?("image")
+        end
+
+        def video?
+          general_type?("video")
+        end
+
+        def audio?
+          general_type?("audio")
+        end
+
+        def text?
+          general_type?("text")
+        end
+
+        def type?(type)
+          matching_mime_type = shrine_class.type_lookup(type)
+
+          fail Error, "type #{type.inspect} is not recognized by the MIME library" unless matching_mime_type
+
+          mime_type! == matching_mime_type
+        end
+
+        private
+
+        def general_type?(type)
+          mime_type!.start_with?(type)
+        end
+
+        def mime_type!
+          mime_type or fail Error, "mime_type metadata value is missing"
+        end
+      end
+
+      class MimeDatabase
+        SUPPORTED_TOOLS = %i[mini_mime mime_types mimemagic marcel rack_mime]
+
+        def initialize(tool)
+          raise Error, "unknown type database #{tool.inspect}, supported databases are: #{SUPPORTED_TOOLS.join(",")}" unless SUPPORTED_TOOLS.include?(tool)
+
+          @tool = tool
+        end
+
+        def call(extension)
+          send(:"lookup_with_#{@tool}", extension)
+        end
+
+        private
+
+        def lookup_with_mini_mime(extension)
+          require "mini_mime"
+
+          info = MiniMime.lookup_by_extension(extension)
+          info&.content_type
+        end
+
+        def lookup_with_mime_types(extension)
+          require "mime/types"
+
+          mime_type = MIME::Types.of(".#{extension}").first
+          mime_type&.content_type
+        end
+
+        def lookup_with_mimemagic(extension)
+          require "mimemagic"
+
+          magic = MimeMagic.by_extension(".#{extension}")
+          magic&.type
+        end
+
+        def lookup_with_marcel(extension)
+          require "marcel"
+
+          type = Marcel::MimeType.for(extension: ".#{extension}")
+          type unless type == "application/octet-stream"
+        end
+
+        def lookup_with_rack_mime(extension)
+          require "rack/mime"
+
+          Rack::Mime.mime_type(".#{extension}", nil)
+        end
+      end
+    end
+
+    register_plugin(:type_predicates, TypePredicates)
+  end
+end

data/lib/shrine/plugins/upload_endpoint.rb

@@ -9,11 +9,11 @@ class Shrine
   module Plugins
     # Documentation can be found on https://shrinerb.com/docs/plugins/upload_endpoint
     module UploadEndpoint
-      def self.load_dependencies(uploader, opts = {})
+      def self.load_dependencies(uploader, **)
         uploader.plugin :rack_file
       end
 
-      def self.configure(uploader, opts = {})
+      def self.configure(uploader, **opts)
         uploader.opts[:upload_endpoint] ||= {}
         uploader.opts[:upload_endpoint].merge!(opts)
       end
@@ -156,7 +156,7 @@ class Shrine
       if @upload
         @upload.call(io, context, request)
       else
-        uploader.upload(io, context)
+        uploader.upload(io, **context)
       end
     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, options = {})
+      def self.configure(uploader, **opts)
         uploader.opts[:upload_options] ||= {}
-        uploader.opts[:upload_options].merge!(options)
+        uploader.opts[:upload_options].merge!(opts)
       end
 
       module InstanceMethods

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, **options)
+      def self.configure(uploader, **opts)
         uploader.opts[:url_options] ||= {}
-        uploader.opts[:url_options].merge!(options)
+        uploader.opts[:url_options].merge!(opts)
       end
 
       module FileMethods

data/lib/shrine/plugins/validation.rb

@@ -29,14 +29,16 @@ class Shrine
           @errors = []
         end
 
-        # Leaves out :validate option when calling `Shrine.upload`.
-        def upload(*args, validate: nil, **options)
-          super(*args, **options)
+        # Performs validations after attaching cached file.
+        def attach_cached(value, validate: nil, **options)
+          result = super(value, validate: false, **options)
+          validation(validate)
+          result
         end
 
-        # Performs validations after changing the file.
-        def change(file, validate: nil, **)
-          result = super
+        # Performs validations after attaching file.
+        def attach(io, validate: nil, **options)
+          result = super(io, **options)
           validation(validate)
           result
         end
@@ -52,7 +54,7 @@ class Shrine
         # Calls validation appropriately based on the :validate value.
         def validation(argument)
           case argument
-          when Hash  then validate(argument)
+          when Hash  then validate(**argument)
           when false then errors.clear # skip validation
           else            validate
           end

data/lib/shrine/storage/linter.rb

@@ -35,7 +35,7 @@ class Shrine
       end
 
       def call(io_factory = default_io_factory)
-        storage.upload(io_factory.call, id = "foo", {})
+        storage.upload(io_factory.call, id = "foo", shrine_metadata: { "foo" => "bar" })
 
         lint_open(id)
         lint_exists(id)
@@ -67,13 +67,13 @@ class Shrine
       end
 
       def lint_open(id)
-        opened = storage.open(id, {})
+        opened = storage.open(id)
         error :open, "doesn't return a valid IO object" if !io?(opened)
         error :open, "returns an empty IO object" if opened.read.empty?
         opened.close
 
         begin
-          storage.open(@nonexisting, {})
+          storage.open(@nonexisting)
           error :open, "should raise an exception on nonexisting file"
         rescue Shrine::FileNotFound
         rescue => exception
@@ -107,7 +107,7 @@ class Shrine
       end
 
       def lint_presign(id)
-        data = storage.presign(id, {})
+        data = storage.presign(id)
         error :presign, "result should be a Hash" unless data.respond_to?(:to_h)
         error :presign, "result should include :method key" unless data.to_h.key?(:method)
         error :presign, "result should include :url key" unless data.to_h.key?(:url)

data/lib/shrine/storage/s3.rb

@@ -103,7 +103,7 @@ class Shrine
       #
       # [`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_object(object(id), options)
+        chunks, length = get(object(id), options)
 
         Down::ChunkedIO.new(chunks: chunks, rewindable: rewindable, size: length)
       rescue Aws::S3::Errors::NoSuchKey
@@ -179,25 +179,7 @@ class Shrine
         options.merge!(@upload_options)
         options.merge!(presign_options)
 
-        if method == :post
-          presigned_post = object(id).presigned_post(options)
-
-          { method: method, url: presigned_post.url, fields: presigned_post.fields }
-        else
-          url = object(id).presigned_url(method, options)
-
-          # 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]
-
-          { method: method, url: url, headers: headers }
-        end
+        send(:"presign_#{method}", id, options)
       end
 
       # Deletes the file from the storage.
@@ -235,6 +217,17 @@ 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|
+            IO.copy_stream(io, write_stream)
+          end
+        end
+      end
+
       # Copies an existing S3 object to a new location. Uses multipart copy for
       # large files.
       def copy(io, id, **copy_options)
@@ -250,15 +243,28 @@ class Shrine
         object(id).copy_from(io.storage.object(io.id), **options)
       end
 
-      # 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|
-            IO.copy_stream(io, write_stream)
-          end
-        end
+      # Generates parameters for a POST upload request.
+      def presign_post(id, options)
+        presigned_post = object(id).presigned_post(options)
+
+        { method: :post, url: presigned_post.url, fields: presigned_post.fields }
+      end
+
+      # Generates parameters for a PUT upload request.
+      def presign_put(id, options)
+        url = object(id).presigned_url(:put, options)
+
+        # 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]
+
+        { method: :put, url: url, headers: headers }
       end
 
       # Determins the part size that should be used when uploading the given IO
@@ -273,18 +279,36 @@ class Shrine
         end
       end
 
-      # Aws::S3::Object#get doesn't allow us to get the content length of the
-      # object before the content is downloaded, so we hack our way around it.
-      def get_object(object, params)
-        req = client.build_request(:get_object, **params, bucket: bucket.name, key: object.key)
+      if Gem::Version.new(Aws::CORE_GEM_VERSION) >= Gem::Version.new("3.104.0")
+        def get(object, params)
+          enum = object.enum_for(:get, **params)
+
+          begin
+            content_length = Integer(enum.peek.last["content-length"])
+          rescue StopIteration
+            content_length = 0
+          end
+
+          chunks = Enumerator.new { |y| loop { y << enum.next.first } }
 
-        body = req.enum_for(:send_request)
-        body.peek # start the request
+          [chunks, content_length]
+        end
+      else
+        def get(object, params)
+          req = client.build_request(:get_object, bucket: bucket.name, key: object.key, **params)
+
+          body = req.enum_for(:send_request)
+          begin
+            body.peek # start the request
+          rescue StopIteration
+            # the S3 object is empty
+          end
 
-        content_length = Integer(req.context.http_response.headers["Content-Length"])
-        chunks         = Enumerator.new { |y| loop { y << body.next } }
+          content_length = Integer(req.context.http_response.headers["Content-Length"])
+          chunks         = Enumerator.new { |y| loop { y << body.next } }
 
-        [chunks, content_length]
+          [chunks, content_length]
+        end
       end
 
       # The file is copyable if it's on S3 and on the same Amazon account.

data/lib/shrine/uploaded_file.rb

@@ -6,7 +6,6 @@ require "uri"
 
 class Shrine
   # Core class that represents a file uploaded to a storage.
-  # Base implementation is defined in InstanceMethods and ClassMethods.
   class UploadedFile
     @shrine_class = ::Shrine
 
@@ -249,6 +248,11 @@ class Shrine
         self.class.shrine_class
       end
 
+      # Returns simplified inspect output.
+      def inspect
+        "#<#{self.class.inspect} storage=#{storage_key.inspect} id=#{id.inspect} metadata=#{metadata.inspect}>"
+      end
+
       private
 
       # Returns an opened IO object for the uploaded file by calling `#open`