shrine 2.13.0 → 2.14.0

data/lib/shrine/plugins/migration_helpers.rb

@@ -65,27 +65,27 @@ class Shrine
 
           return if shrine_class.opts[:migration_helpers_delegate] == false
 
-          module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def update_#{name}(&block)
-              #{name}_attacher.update_stored(&block)
-            end
+          name = attachment_name
 
-            def #{name}_cache
-              #{name}_attacher.cache
-            end
+          define_method :"update_#{name}" do |&block|
+            send(:"#{name}_attacher").update_stored(&block)
+          end
 
-            def #{name}_store
-              #{name}_attacher.store
-            end
+          define_method :"#{name}_cache" do
+            send(:"#{name}_attacher").cache
+          end
 
-            def #{name}_cached?
-              #{name}_attacher.cached?
-            end
+          define_method :"#{name}_store" do
+            send(:"#{name}_attacher").store
+          end
 
-            def #{name}_stored?
-              #{name}_attacher.stored?
-            end
-          RUBY
+          define_method :"#{name}_cached?" do
+            send(:"#{name}_attacher").cached?
+          end
+
+          define_method :"#{name}_stored?" do
+            send(:"#{name}_attacher").stored?
+          end
         end
       end
 

data/lib/shrine/plugins/module_include.rb

@@ -19,15 +19,16 @@ class Shrine
     #       def included(model)
     #         super
     #
-    #         module_eval <<-RUBY, __FILE__, __LINE__ + 1
-    #           def #{@name}_size(version)
-    #             if #{@name}.is_a?(Hash)
-    #               #{@name}[version].size
-    #             else
-    #               #{@name}.size if #{@name}
-    #             end
+    #         name = attachment_name
+    #
+    #         define_method :"#{name}_size" do |version|
+    #           attachment = send(name)
+    #           if attachment.is_a?(Hash)
+    #             attachment[version].size
+    #           elsif attachment
+    #             attachment.size
     #           end
-    #         RUBY
+    #         end
     #       end
     #     end
     #

data/lib/shrine/plugins/presign_endpoint.rb

@@ -75,16 +75,20 @@ class Shrine
     # `:presign_options`, here is an example for S3 storage:
     #
     #     plugin :presign_endpoint, presign_options: -> (request) do
-    #       filename     = request.params["filename"]
-    #       type         = request.params["type"]
+    #       # Uppy will send the "filename" and "type" query parameters
+    #       filename = request.params["filename"]
+    #       type     = request.params["type"]
     #
     #       {
-    #         content_length_range: 0..(10*1024*1024),                 # limit filesize to 10MB
-    #         content_disposition: "inline; filename=\"#{filename}\"", # download with original filename
-    #         content_type:        type,                               # set correct content type
+    #         content_length_range: 0..(10*1024*1024),                  # limit filesize to 10MB
+    #         content_disposition: ContentDisposition.inline(filename), # download with original filename
+    #         content_type:        type,                                # set correct content type
     #       }
     #     end
     #
+    # The example above uses the [content_disposition] gem to correctly format
+    # the `Content-Disposition` header value.
+    #
     # The `:presign_options` can be a Proc or a Hash.
     #
     # ## Presign
@@ -116,6 +120,7 @@ class Shrine
     # [Amazon S3]: https://aws.amazon.com/s3/
     # [Google Cloud Storage]: https://cloud.google.com/storage/
     # [Microsoft Azure Storage]: https://azure.microsoft.com/en-us/services/storage/
+    # [content_disposition]: https://github.com/shrinerb/content_disposition
     module PresignEndpoint
       def self.configure(uploader, opts = {})
         uploader.opts[:presign_endpoint_presign_location] = opts.fetch(:presign_location, uploader.opts[:presign_endpoint_presign_location])
@@ -133,14 +138,15 @@ class Shrine
         # Additional options can be given to override the options given on
         # plugin initialization.
         def presign_endpoint(storage_key, **options)
-          App.new({
+          App.new(
             shrine_class:     self,
             storage_key:      storage_key,
             presign_location: opts[:presign_endpoint_presign_location],
             presign_options:  opts[:presign_endpoint_presign_options],
             presign:          opts[:presign_endpoint_presign],
             rack_response:    opts[:presign_endpoint_rack_response],
-          }.merge(options))
+            **options
+          )
         end
       end
 

data/lib/shrine/plugins/processing.rb

@@ -59,7 +59,7 @@ class Shrine
     # [image_processing]: https://github.com/janko-m/image_processing
     module Processing
       def self.configure(uploader)
-        uploader.opts[:processing] = {}
+        uploader.opts[:processing] ||= {}
       end
 
       module ClassMethods

data/lib/shrine/plugins/rack_response.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "rack"
+require "content_disposition"
 
 class Shrine
   module Plugins
@@ -29,27 +30,52 @@ class Shrine
     #     class FilesController < ActionController::Base
     #       def download
     #         # ...
-    #         file_status, file_headers, file_body = record.attachment.to_rack_response
+    #         set_rack_response record.attachment.to_rack_response
+    #       end
+    #
+    #       private
     #
-    #         response.status = file_status
-    #         response.headers.merge!(file_headers)
-    #         self.response_body = file_body
+    #       def set_rack_response((status, headers, body))
+    #         self.status = status
+    #         self.headers.merge!(headers)
+    #         self.response_body = body
     #       end
     #     end
     #
+    # The `#each` method on the response body object will stream the uploaded
+    # file directly from the storage. It also works with [Rack::Sendfile] when
+    # using `FileSystem` storage.
+    #
+    # ## Type
+    #
+    # The response `Content-Type` header will default to the value of the
+    # `mime_type` metadata. A custom content type can be provided via the
+    # `:type` option:
+    #
+    #     _, headers, _ uploaded_file.to_rack_response(type: "text/plain; charset=utf-8")
+    #     headers["Content-Type"] #=> "text/plain; charset=utf-8"
+    #
+    # ## Filename
+    #
+    # The download filename in the `Content-Disposition` header will default to
+    # the value of the `filename` metadata. A custom download filename can be
+    # provided via the `:filename` option:
+    #
+    #     _, headers, _ uploaded_file.to_rack_response(filename: "my-filename.txt")
+    #     headers["Content-Disposition"] #=> "inline; filename=\"my-filename.txt\""
+    #
     # ## Disposition
     #
-    # 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:
+    # The default disposition in the "Content-Disposition" header is `inline`,
+    # but it can be changed via the `:disposition` option:
     #
-    #     status, headers, body = uploaded_file.to_rack_response(disposition: "attachment")
+    #     _, headers, _ = uploaded_file.to_rack_response(disposition: "attachment")
     #     headers["Content-Disposition"] #=> "attachment; filename=\"file.txt\""
     #
     # ## Range
     #
     # [Partial responses][range requests] are also supported via the `:range`
-    # parameter, which accepts a value of the `Range` request header.
+    # option, which accepts a value of the `Range` request header.
     #
     #     env["HTTP_RANGE"] #=> "bytes=100-200"
     #     status, headers, body = uploaded_file.to_rack_response(range: env["HTTP_RANGE"])
@@ -59,35 +85,55 @@ class Shrine
     #     body                      # partial content
     #
     # [range requests]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Range_requests
+    # [Rack::Sendfile]: https://www.rubydoc.info/github/rack/rack/Rack/Sendfile
     module RackResponse
       module FileMethods
         # Returns a Rack response triple for the uploaded file.
-        def to_rack_response(disposition: "inline", range: false)
-          range = parse_http_range(range) if range
+        def to_rack_response(**options)
+          FileResponse.new(self).call(**options)
+        end
+      end
+
+      class FileResponse
+        attr_reader :file
+
+        def initialize(file)
+          @file = file
+        end
+
+        # Returns a Rack response triple for the uploaded file.
+        def call(**options)
+          options[:range] = parse_content_range(options[:range]) if options[:range]
 
-          status  = range ? 206 : 200
-          headers = rack_headers(disposition: disposition, range: range)
-          body    = rack_body(range: range)
+          status  = rack_status(**options)
+          headers = rack_headers(**options)
+          body    = rack_body(**options)
 
           [status, headers, body]
         end
 
         private
 
+        # Returns "200 OK" on full request, and "206 Partial Content" on ranged
+        # request.
+        def rack_status(range: nil, **)
+          range ? 206 : 200
+        end
+
         # Returns a hash of "Content-Length", "Content-Type" and
         # "Content-Disposition" headers, whose values are extracted from
         # metadata. Also returns the correct "Content-Range" header on ranged
         # requests.
-        def rack_headers(disposition:, range: false)
-          length   = range ? range.size : size || io.size
-          type     = mime_type || Rack::Mime.mime_type(".#{extension}")
-          filename = original_filename || id.split("/").last
+        def rack_headers(filename: nil, type: nil, disposition: "inline", range: false)
+          length     = range ? range.size : size
+          type     ||= @file.mime_type || Rack::Mime.mime_type(".#{@file.extension}")
+          filename ||= @file.original_filename || @file.id.split("/").last
 
           headers = {}
           headers["Content-Length"]      = length.to_s if length
           headers["Content-Type"]        = type
-          headers["Content-Disposition"] = "#{disposition}; filename=\"#{filename}\""
-          headers["Content-Range"]       = "bytes #{range.begin}-#{range.end}/#{size||io.size}" if range
+          headers["Content-Disposition"] = content_disposition(disposition: disposition, filename: filename)
+          headers["Content-Range"]       = "bytes #{range.begin}-#{range.end}/#{size}" if range
           headers["Accept-Ranges"]       = "bytes" unless range == false
 
           headers
@@ -95,19 +141,69 @@ class Shrine
 
         # Returns an object that responds to #each and #close, which yields
         # contents of the file.
-        def rack_body(range: nil)
+        def rack_body(range: nil, **)
+          FileBody.new(file, range: range)
+        end
+
+        # Parses the value of a "Range" HTTP header.
+        def parse_content_range(range_header)
+          if Rack.release >= "2.0"
+            ranges = Rack::Utils.get_byte_ranges(range_header, size)
+          else
+            ranges = Rack::Utils.byte_ranges({"HTTP_RANGE" => range_header}, size)
+          end
+
+          ranges.first if ranges && ranges.one?
+        end
+
+        def content_disposition(disposition:, filename:)
+          ContentDisposition.format(disposition: disposition, filename: filename)
+        end
+
+        # Read size from metadata, otherwise retrieve the size from the storage.
+        def size
+          @file.size || @file.to_io.size
+        end
+      end
+
+      # Implements the interface of a Rack response body object.
+      class FileBody
+        attr_reader :file, :range
+
+        def initialize(file, range: nil)
+          @file  = file
+          @range = range
+        end
+
+        # Streams the uploaded file directly from the storage.
+        def each(&block)
           if range
-            body = enum_for(:read_partial_chunks, range)
+            read_partial_chunks(&block)
           else
-            body = enum_for(:read_chunks)
+            read_chunks(&block)
           end
+        end
+
+        # Closes the file when response body is closed by the web server.
+        def close
+          file.close
+        end
 
-          Rack::BodyProxy.new(body) { io.close }
+        # Rack::Sendfile is activated when response body responds to #to_path.
+        def respond_to_missing?(name, include_private = false)
+          name == :to_path && path
         end
 
+        # Rack::Sendfile is activated when response body responds to #to_path.
+        def method_missing(name, *args, &block)
+          name == :to_path && path or super
+        end
+
+        private
+
         # Yields reasonably sized chunks of uploaded file's partial content
         # specified by the given index range.
-        def read_partial_chunks(range)
+        def read_partial_chunks
           bytes_read = 0
 
           read_chunks do |chunk|
@@ -130,22 +226,18 @@ class Shrine
 
         # Yields reasonably sized chunks of uploaded file's content.
         def read_chunks
-          if io.respond_to?(:each_chunk) # Down::ChunkedIO
-            io.each_chunk { |chunk| yield chunk }
+          if file.to_io.respond_to?(:each_chunk) # Down::ChunkedIO
+            file.to_io.each_chunk { |chunk| yield chunk }
           else
-            yield io.read(16*1024) until io.eof?
+            yield file.read(16*1024) until file.eof?
           end
         end
 
-        # Parses the value of a "Range" HTTP header.
-        def parse_http_range(range_header)
-          if Rack.release >= "2.0"
-            ranges = Rack::Utils.get_byte_ranges(range_header, size || io.size)
-          else
-            ranges = Rack::Utils.byte_ranges({"HTTP_RANGE" => range_header}, size || io.size)
+        # Returns actual path on disk when FileSystem storage is used.
+        def path
+          if defined?(Storage::FileSystem) && file.storage.is_a?(Storage::FileSystem)
+            file.storage.path(file.id)
           end
-
-          ranges.first if ranges && ranges.one?
         end
       end
     end

data/lib/shrine/plugins/refresh_metadata.rb

@@ -7,9 +7,10 @@ class Shrine
     #
     #     plugin :refresh_metadata
     #
-    # It provides `UploadedFile#refresh_metadata!` method, which calls
-    # `Shrine#extract_metadata` with the uploaded file opened for reading,
-    # and updates the existing metadata hash with the results.
+    # It provides `UploadedFile#refresh_metadata!` method, which triggers
+    # metadata extraction (calls `Shrine#extract_metadata`) with the uploaded
+    # file opened for reading, and updates the existing metadata hash with the
+    # results.
     #
     #     uploaded_file.refresh_metadata!
     #     uploaded_file.metadata # re-extracted metadata
@@ -17,11 +18,25 @@ class Shrine
     # For remote storages this will make an HTTP request to open the file for
     # reading, but only the portion of the file needed for extracting each
     # metadata value will be downloaded.
+    #
+    # If the uploaded file is already open, it is passed to metadata extraction
+    # as is.
+    #
+    #     uploaded_file.open do
+    #       uploaded_file.refresh_metadata!
+    #       # ...
+    #     end
     module RefreshMetadata
       module FileMethods
         def refresh_metadata!(context = {})
-          refreshed_metadata = open { uploader.extract_metadata(self, context) }
-          metadata.merge!(refreshed_metadata)
+          refreshed_metadata =
+            if @io
+              uploader.extract_metadata(self, context)
+            else
+              open { uploader.extract_metadata(self, context) }
+            end
+
+          @data = @data.merge("metadata" => metadata.merge(refreshed_metadata))
         end
       end
     end

data/lib/shrine/plugins/remote_url.rb

@@ -102,15 +102,15 @@ class Shrine
         def initialize(*)
           super
 
-          module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{@name}_remote_url=(url)
-              #{@name}_attacher.remote_url = url
-            end
+          name = attachment_name
 
-            def #{@name}_remote_url
-              #{@name}_attacher.remote_url
-            end
-          RUBY
+          define_method :"#{name}_remote_url=" do |url|
+            send(:"#{name}_attacher").remote_url = url
+          end
+
+          define_method :"#{name}_remote_url" do
+            send(:"#{name}_attacher").remote_url
+          end
         end
       end
 

data/lib/shrine/plugins/remove_attachment.rb

@@ -17,15 +17,15 @@ class Shrine
         def initialize(*)
           super
 
-          module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def remove_#{@name}=(value)
-              #{@name}_attacher.remove = value
-            end
-
-            def remove_#{@name}
-              #{@name}_attacher.remove
-            end
-          RUBY
+          name = attachment_name
+
+          define_method :"remove_#{name}=" do |value|
+            send(:"#{name}_attacher").remove = value
+          end
+
+          define_method :"remove_#{name}" do
+            send(:"#{name}_attacher").remove
+          end
         end
       end