shrine 2.16.0 → 2.17.0

data/lib/shrine/plugins/metadata_attributes.rb

@@ -18,7 +18,7 @@ class Shrine
       end
 
       module AttacherMethods
-        def assign(value)
+        def assign(value, **options)
           super
           cached_file = get
 

data/lib/shrine/plugins/parsed_json.rb

@@ -17,8 +17,9 @@ class Shrine
 
         private
 
-        def parsed_json?(hash)
-          hash.keys.any? { |key| key.is_a?(String) }
+        def parsed_json?(value)
+          (value.key?('id') || value.key?(:id)) &&
+          (value.key?('storage') || value.key?(:storage))
         end
       end
     end

data/lib/shrine/plugins/presign_endpoint.rb

@@ -11,10 +11,8 @@ class Shrine
     # [doc/plugins/presign_endpoint.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/presign_endpoint.md
     module PresignEndpoint
       def self.configure(uploader, opts = {})
-        uploader.opts[:presign_endpoint_presign_location] = opts.fetch(:presign_location, uploader.opts[:presign_endpoint_presign_location])
-        uploader.opts[:presign_endpoint_presign_options] = opts.fetch(:presign_options, uploader.opts[:presign_endpoint_presign_options])
-        uploader.opts[:presign_endpoint_presign] = opts.fetch(:presign, uploader.opts[:presign_endpoint_presign])
-        uploader.opts[:presign_endpoint_rack_response] = opts.fetch(:rack_response, uploader.opts[:presign_endpoint_rack_response])
+        uploader.opts[:presign_endpoint] ||= {}
+        uploader.opts[:presign_endpoint].merge!(opts)
       end
 
       module ClassMethods
@@ -26,142 +24,148 @@ class Shrine
         # Additional options can be given to override the options given on
         # plugin initialization.
         def presign_endpoint(storage_key, **options)
-          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],
-            **options
+          Shrine::PresignEndpoint.new(
+            shrine_class: self,
+            storage_key:  storage_key,
+            **opts[:presign_endpoint],
+            **options,
           )
         end
       end
+    end
 
-      # Rack application that accepts GET request to the root URL, calls
-      # `#presign` on the specified storage, and returns that information in
-      # JSON format.
-      class App
-        CONTENT_TYPE_JSON = "application/json; charset=utf-8"
-        CONTENT_TYPE_TEXT = "text/plain"
-
-        # Writes given options to instance variables.
-        def initialize(options)
-          options.each do |name, value|
-            instance_variable_set("@#{name}", value)
-          end
-        end
+    register_plugin(:presign_endpoint, PresignEndpoint)
+  end
 
-        # Accepts a Rack env hash, routes GET 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)
+  # Rack application that accepts GET request to the root URL, calls
+  # `#presign` on the specified storage, and returns that information in
+  # JSON format.
+  class PresignEndpoint
+    CONTENT_TYPE_JSON = "application/json; charset=utf-8"
+    CONTENT_TYPE_TEXT = "text/plain"
+
+    # Writes given options to instance variables.
+    def initialize(options)
+      options.each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
+    end
 
-          status, headers, body = catch(:halt) do
-            error!(404, "Not Found") unless ["", "/"].include?(request.path_info)
-            error!(405, "Method Not Allowed") unless request.get?
+    # Accepts a Rack env hash, routes GET 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)
 
-            handle_request(request)
-          end
+      status, headers, body = catch(:halt) do
+        error!(404, "Not Found") unless ["", "/"].include?(request.path_info)
+        error!(405, "Method Not Allowed") unless request.get?
 
-          headers["Content-Length"] = body.map(&:bytesize).inject(0, :+).to_s
+        handle_request(request)
+      end
 
-          [status, headers, body]
-        end
+      headers["Content-Length"] ||= body.map(&:bytesize).inject(0, :+).to_s
 
-        private
+      [status, headers, body]
+    end
 
-        # Accepts a `Rack::Request` object, generates the presign, and returns a
-        # Rack response.
-        def handle_request(request)
-          location = get_presign_location(request)
-          options  = get_presign_options(request)
+    def inspect
+      "#<#{@shrine_class}::PresignEndpoint(:#{@storage_key})>"
+    end
+    alias to_s inspect
 
-          presign = generate_presign(location, options, request)
+    private
 
-          make_response(presign, request)
-        end
+    # Accepts a `Rack::Request` object, generates the presign, and returns a
+    # Rack response.
+    def handle_request(request)
+      location = get_presign_location(request)
+      options  = get_presign_options(request)
 
-        # Generates the location using `Shrine#generate_uid`, and extracts the
-        # extension from the `filename` query parameter. If `:presign_location`
-        # option is given, calls that instead.
-        def get_presign_location(request)
-          if @presign_location
-            @presign_location.call(request)
-          else
-            extension = File.extname(request.params["filename"].to_s)
-            uploader.send(:generate_uid, nil) + extension
-          end
-        end
+      presign = generate_presign(location, options, request)
 
-        # Calls `:presign_options` option block if given.
-        def get_presign_options(request)
-          options = @presign_options
-          options = options.call(request) if options.respond_to?(:call)
-          options || {}
-        end
+      make_response(presign, request)
+    end
 
-        # Calls `#presign` on the storage, and returns the `url`, `fields`, and
-        # `headers` information in a serialializable format. If `:presign`
-        # option is given, calls that instead of calling `#presign`.
-        def generate_presign(location, options, request)
-          if @presign
-            data = @presign.call(location, options, request)
-          else
-            data = storage.presign(location, options)
-          end
-
-          if data.respond_to?(:to_h)
-            { fields: {}, headers: {} }.merge(data.to_h)
-          else
-            Shrine.deprecation("Returning a custom object in Storage#presign is deprecated, presign_endpoint will not support it in Shrine 3. Storage#presign should return a Hash instead.")
-
-            url     = data.url
-            fields  = data.fields
-            headers = data.headers if data.respond_to?(:headers)
-
-            { url: url, fields: fields.to_h, headers: headers.to_h }
-          end
-        end
+    # Generates the location using `Shrine#generate_uid`, and extracts the
+    # extension from the `filename` query parameter. If `:presign_location`
+    # option is given, calls that instead.
+    def get_presign_location(request)
+      if @presign_location
+        @presign_location.call(request)
+      else
+        extension = File.extname(request.params["filename"].to_s)
+        uploader.send(:generate_uid, nil) + extension
+      end
+    end
 
-        # Transforms the presign hash 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 `:rack_response` option is given,
-        # calls that instead.
-        def make_response(object, request)
-          if @rack_response
-            response = @rack_response.call(object, request)
-          else
-            response = [200, { "Content-Type" => CONTENT_TYPE_JSON }, [object.to_json]]
-          end
-
-          # prevent browsers from caching the response
-          response[1]["Cache-Control"] = "no-store" unless response[1].key?("Cache-Control")
-
-          response
-        end
+    # Calls `:presign_options` option block if given.
+    def get_presign_options(request)
+      options = @presign_options
+      options = options.call(request) if options.respond_to?(:call)
+      options || {}
+    end
 
-        # Used for early returning an error response.
-        def error!(status, message)
-          throw :halt, [status, { "Content-Type" => CONTENT_TYPE_TEXT }, [message]]
-        end
+    # Calls `#presign` on the storage, and returns the `url`, `fields`, and
+    # `headers` information in a serialializable format. If `:presign`
+    # option is given, calls that instead of calling `#presign`.
+    def generate_presign(location, options, request)
+      if @presign
+        data = @presign.call(location, options, request)
+      else
+        data = storage.presign(location, options)
+      end
 
-        # Returns the uploader around the specified storage.
-        def uploader
-          @shrine_class.new(@storage_key)
-        end
+      if data.respond_to?(:to_h)
+        { fields: {}, headers: {} }.merge(data.to_h)
+      else
+        Shrine.deprecation("Returning a custom object in Storage#presign is deprecated, presign_endpoint will not support it in Shrine 3. Storage#presign should return a Hash instead.")
 
-        # Returns the storage object.
-        def storage
-          @shrine_class.find_storage(@storage_key)
-        end
+        url     = data.url
+        fields  = data.fields
+        headers = data.headers if data.respond_to?(:headers)
+
+        { url: url, fields: fields.to_h, headers: headers.to_h }
       end
     end
 
-    register_plugin(:presign_endpoint, PresignEndpoint)
+    # Transforms the presign hash 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 `:rack_response` option is given,
+    # calls that instead.
+    def make_response(object, request)
+      if @rack_response
+        response = @rack_response.call(object, request)
+      else
+        response = [200, { "Content-Type" => CONTENT_TYPE_JSON }, [object.to_json]]
+      end
+
+      # prevent browsers from caching the response
+      response[1]["Cache-Control"] = "no-store" unless response[1].key?("Cache-Control")
+
+      response
+    end
+
+    # Used for early returning an error response.
+    def error!(status, message)
+      throw :halt, [status, { "Content-Type" => CONTENT_TYPE_TEXT }, [message]]
+    end
+
+    # Returns the uploader around the specified storage.
+    def uploader
+      @shrine_class.new(@storage_key)
+    end
+
+    # Returns the storage object.
+    def storage
+      @shrine_class.find_storage(@storage_key)
+    end
   end
+
+  # backwards compatibility
+  Plugins::PresignEndpoint.const_set(:App, PresignEndpoint)
+  Plugins::PresignEndpoint.deprecate_constant(:App)
 end

data/lib/shrine/plugins/processing.rb

@@ -13,7 +13,7 @@ class Shrine
       module ClassMethods
         def process(action, &block)
           opts[:processing][action] ||= []
-          opts[:processing][action] << block
+          opts[:processing][action] += [block]
         end
       end
 

data/lib/shrine/plugins/rack_response.rb

@@ -2,6 +2,7 @@
 
 require "rack"
 require "content_disposition"
+require "digest"
 
 class Shrine
   module Plugins
@@ -49,18 +50,49 @@ class Shrine
         # metadata. Also returns the correct "Content-Range" header on ranged
         # requests.
         def rack_headers(filename: nil, type: nil, disposition: "inline", range: false)
-          length     = range ? range.size : file.size
-          type     ||= file.mime_type || Rack::Mime.mime_type(".#{file.extension}", nil)
+          {
+            "Content-Length"      => content_length(range),
+            "Content-Type"        => content_type(type),
+            "Content-Disposition" => content_disposition(disposition, filename),
+            "Content-Range"       => content_range(range),
+            "Accept-Ranges"       => accept_ranges(range),
+            "ETag"                => etag,
+          }.compact
+        end
+
+        # Value for the "Content-Length" header.
+        def content_length(range)
+          length = range ? range.size : file.size
+          length.to_s if length
+        end
+
+        # Value for the "Content-Type" header.
+        def content_type(type)
+          type || file.mime_type || Rack::Mime.mime_type(".#{file.extension}", nil)
+        end
+
+        # Value for the "Content-Disposition" header.
+        def content_disposition(disposition, filename)
           filename ||= file.original_filename || file.id.split("/").last
 
-          headers = {}
-          headers["Content-Length"]      = length.to_s if length
-          headers["Content-Type"]        = type if type
-          headers["Content-Disposition"] = content_disposition(disposition, filename)
-          headers["Content-Range"]       = "bytes #{range.begin}-#{range.end}/#{file.size}" if range
-          headers["Accept-Ranges"]       = "bytes" unless range == false
+          ContentDisposition.format(disposition: disposition, filename: filename)
+        end
+
+        # Value for the "Content-Range" header.
+        def content_range(range)
+          "bytes #{range.begin}-#{range.end}/#{file.size}" if range
+        end
+
+        # Value for the "Accept-Ranges" header.
+        def accept_ranges(range)
+          "bytes" unless range == false
+        end
+
+        # Value for the "ETag" header.
+        def etag
+          digest = Digest::SHA256.hexdigest("#{file.shrine_class}-#{file.storage_key}-#{file.id}")
 
-          headers
+          %(W/"#{digest.byteslice(0, 32)}")
         end
 
         # Returns an object that responds to #each and #close, which yields
@@ -79,10 +111,6 @@ class Shrine
 
           ranges.first if ranges && ranges.one?
         end
-
-        def content_disposition(disposition, filename)
-          ContentDisposition.format(disposition: disposition, filename: filename)
-        end
       end
 
       # Implements the interface of a Rack response body object.
@@ -128,9 +156,12 @@ class Shrine
           read_chunks do |chunk|
             chunk_range = bytes_read..(bytes_read + chunk.bytesize - 1)
 
-            if chunk_range.begin >= range.begin && chunk_range.end <= range.end
+            if chunk_range.begin > range.end
+              # no more chunks will match
+              return
+            elsif chunk_range.begin >= range.begin && chunk_range.end <= range.end
               yield chunk
-            elsif chunk_range.end >= range.begin || chunk_range.end <= range.end
+            elsif chunk_range.end >= range.begin && chunk_range.begin <= range.end
               requested_range_begin = [chunk_range.begin, range.begin].max - bytes_read
               requested_range_end   = [chunk_range.end, range.end].min - bytes_read
 

data/lib/shrine/plugins/remote_url.rb

@@ -36,7 +36,7 @@ class Shrine
         # Downloads the remote file and assigns it. If download failed, sets
         # the error message and assigns the url to an instance variable so that
         # it shows up in the form.
-        def assign_remote_url(url, downloader: {})
+        def assign_remote_url(url, downloader: {}, **options)
           return if url == "" || url.nil?
 
           begin
@@ -46,7 +46,7 @@ class Shrine
           end
 
           if downloaded_file
-            assign(downloaded_file)
+            assign(downloaded_file, **options)
           else
             message = download_error_message(url, download_error)
             errors.replace [message]

data/lib/shrine/plugins/upload_endpoint.rb

@@ -16,10 +16,8 @@ class Shrine
       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])
+        uploader.opts[:upload_endpoint] ||= {}
+        uploader.opts[:upload_endpoint].merge!(opts)
       end
 
       module ClassMethods
@@ -31,132 +29,138 @@ class Shrine
         # 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],
-            **options
+          Shrine::UploadEndpoint.new(
+            shrine_class: self,
+            storage_key:  storage_key,
+            **opts[:upload_endpoint],
+            **options,
           )
         end
       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
-        CONTENT_TYPE_JSON = "application/json; charset=utf-8"
-        CONTENT_TYPE_TEXT = "text/plain"
-
-        # Writes given options to instance variables.
-        def initialize(options)
-          options.each do |name, value|
-            instance_variable_set("@#{name}", value)
-          end
-        end
+    register_plugin(:upload_endpoint, UploadEndpoint)
+  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)
+  # 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 UploadEndpoint
+    CONTENT_TYPE_JSON = "application/json; charset=utf-8"
+    CONTENT_TYPE_TEXT = "text/plain"
+
+    # Writes given options to instance variables.
+    def initialize(options)
+      options.each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
+    end
 
-          status, headers, body = catch(:halt) do
-            error!(404, "Not Found") unless ["", "/"].include?(request.path_info)
-            error!(405, "Method Not Allowed") unless request.post?
+    # 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)
 
-            handle_request(request)
-          end
+      status, headers, body = catch(:halt) do
+        error!(404, "Not Found") unless ["", "/"].include?(request.path_info)
+        error!(405, "Method Not Allowed") unless request.post?
 
-          headers["Content-Length"] = body.map(&:bytesize).inject(0, :+).to_s
+        handle_request(request)
+      end
 
-          [status, headers, body]
-        end
+      headers["Content-Length"] ||= body.map(&:bytesize).inject(0, :+).to_s
 
-        private
+      [status, headers, body]
+    end
 
-        # 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)
+    def inspect
+      "#<#{@shrine_class}::UploadEndpoint(:#{@storage_key})>"
+    end
+    alias to_s inspect
 
-          uploaded_file = upload(io, context, request)
+    private
 
-          make_response(uploaded_file, request)
-        end
+    # 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)
 
-        # 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"]
+      uploaded_file = upload(io, context, request)
 
-          error!(400, "Upload Not Found") if file.nil?
-          error!(400, "Upload Not Valid") unless file.is_a?(Hash) && file[:tempfile]
-          error!(413, "Upload Too Large") if @max_size && file[:tempfile].size > @max_size
+      make_response(uploaded_file, request)
+    end
 
-          verify_checksum!(file[:tempfile], request.env["HTTP_CONTENT_MD5"]) if request.env["HTTP_CONTENT_MD5"]
+    # 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"]
 
-          @shrine_class.rack_file(file)
-        end
+      error!(400, "Upload Not Found") if file.nil?
+      error!(400, "Upload Not Valid") unless file.is_a?(Hash) && file[:tempfile]
+      error!(413, "Upload Too Large") if @max_size && file[:tempfile].size > @max_size
 
-        # 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
+      verify_checksum!(file[:tempfile], request.env["HTTP_CONTENT_MD5"]) if request.env["HTTP_CONTENT_MD5"]
 
-        # 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
+      @shrine_class.rack_file(file)
+    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" => CONTENT_TYPE_JSON }, [object.to_json]]
-          end
-        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
 
-        # Verifies the provided checksum against the received file.
-        def verify_checksum!(file, provided_checksum)
-          error!(400, "The Content-MD5 you specified was invalid") if provided_checksum.length != 24
+    # 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
 
-          calculated_checksum = Digest::MD5.file(file.path).base64digest
-          error!(460, "The Content-MD5 you specified did not match what was recieved") if provided_checksum != calculated_checksum
-        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" => CONTENT_TYPE_JSON }, [object.to_json]]
+      end
+    end
 
-        # Used for early returning an error response.
-        def error!(status, message)
-          throw :halt, [status, { "Content-Type" => CONTENT_TYPE_TEXT }, [message]]
-        end
+    # Verifies the provided checksum against the received file.
+    def verify_checksum!(file, provided_checksum)
+      error!(400, "The Content-MD5 you specified was invalid") if provided_checksum.length != 24
 
-        # Returns the uploader around the specified storage.
-        def uploader
-          @shrine_class.new(@storage_key)
-        end
-      end
+      calculated_checksum = Digest::MD5.file(file.path).base64digest
+      error!(460, "The Content-MD5 you specified did not match what was recieved") if provided_checksum != calculated_checksum
     end
 
-    register_plugin(:upload_endpoint, UploadEndpoint)
+    # Used for early returning an error response.
+    def error!(status, message)
+      throw :halt, [status, { "Content-Type" => CONTENT_TYPE_TEXT }, [message]]
+    end
+
+    # Returns the uploader around the specified storage.
+    def uploader
+      @shrine_class.new(@storage_key)
+    end
   end
+
+  # backwards compatibility
+  Plugins::UploadEndpoint.const_set(:App, UploadEndpoint)
+  Plugins::UploadEndpoint.deprecate_constant(:App)
 end