shrine 2.16.0 → 2.17.0

data/lib/shrine/plugins/derivation_endpoint.rb

@@ -308,13 +308,25 @@ class Shrine
       # serializes the source uploaded file into an URL-safe format
       source_component = source.urlsafe_dump(metadata: metadata)
 
+      # generate plain URL
+      url = plain_url(name, *args, source_component, params)
+
       # generate signed URL
-      signed_url(name, *args, source_component, params)
+      signed_url(url)
+    end
+
+    def plain_url(*components, params)
+      # When using Rack < 2, Rack::Utils#escape_path will escape '/'.
+      # Escape each component and then join them together.
+      path  = components.map{|component| Rack::Utils.escape_path(component.to_s)}.join('/')
+      query = Rack::Utils.build_query(params)
+
+      "#{path}?#{query}"
     end
 
-    def signed_url(*components)
+    def signed_url(url)
       signer = UrlSigner.new(secret_key)
-      signer.signed_url(*components)
+      signer.sign_url(url)
     end
   end
 
@@ -383,6 +395,11 @@ class Shrine
       [status, headers, body]
     end
 
+    def inspect
+      "#<#{@shrine_class}::DerivationEndpoint>"
+    end
+    alias to_s inspect
+
     private
 
     # Return an error response if the signature is invalid.
@@ -449,19 +466,13 @@ class Shrine
 
       status = response[0]
 
-      content_type   = type || response[1]["Content-Type"]
-      content_length = response[1]["Content-Length"]
-      content_range  = response[1]["Content-Range"]
-
-      filename  = self.filename
-      filename += File.extname(file.path) if File.extname(filename).empty?
-
-      headers = {}
-      headers["Content-Type"]        = content_type if content_type
-      headers["Content-Disposition"] = content_disposition(filename)
-      headers["Content-Length"]      = content_length
-      headers["Content-Range"]       = content_range if content_range
-      headers["Accept-Ranges"]       = "bytes"
+      headers = {
+        "Content-Type"        => type || response[1]["Content-Type"],
+        "Content-Length"      => response[1]["Content-Length"],
+        "Content-Disposition" => content_disposition(file),
+        "Content-Range"       => response[1]["Content-Range"],
+        "Accept-Ranges"       => "bytes",
+      }.compact
 
       body = Rack::BodyProxy.new(response[2]) { File.delete(file.path) }
 
@@ -523,7 +534,10 @@ class Shrine
 
     # Returns disposition and filename formatted for the `Content-Disposition`
     # header.
-    def content_disposition(filename)
+    def content_disposition(file)
+      filename  = self.filename
+      filename += File.extname(file.path) if File.extname(filename).empty?
+
       ContentDisposition.format(disposition: disposition, filename: filename)
     end
   end
@@ -631,7 +645,8 @@ class Shrine
         uploader.upload uploadable,
           location:       upload_location,
           upload_options: upload_options,
-          delete:         false # disable delete_raw plugin
+          delete:         false, # disable delete_raw plugin
+          move:           false # disable moving plugin
       end
     end
 
@@ -705,15 +720,14 @@ class Shrine
       @secret_key = secret_key
     end
 
-    # Returns a URL with the `signature` query parameter generated from the
-    # given path components and query parameters.
-    def signed_url(*components, params)
-      path  = Rack::Utils.escape_path(components.join("/"))
-      query = Rack::Utils.build_query(params)
+    # Returns a URL with the `signature` query parameter
+    def sign_url(url)
+      path, query = url.split("?")
 
-      signature = generate_signature("#{path}?#{query}")
+      params = Rack::Utils.parse_query(query.to_s)
+      params.merge!("signature" => generate_signature(url))
 
-      query = Rack::Utils.build_query(params.merge(signature: signature))
+      query = Rack::Utils.build_query(params)
 
       "#{path}?#{query}"
     end
@@ -722,12 +736,13 @@ class Shrine
     # value in the `signature` query parameter. Raises `InvalidSignature` if
     # the `signature` parameter is missing or its value doesn't match the
     # calculated signature.
-    def verify_url(path_with_query)
-      path, query = path_with_query.split("?")
+    def verify_url(url)
+      path, query = url.split("?")
 
       params    = Rack::Utils.parse_query(query.to_s)
       signature = params.delete("signature")
-      query     = Rack::Utils.build_query(params)
+
+      query = Rack::Utils.build_query(params)
 
       verify_signature("#{path}?#{query}", signature)
     end

data/lib/shrine/plugins/determine_mime_type.rb

@@ -13,6 +13,7 @@ class Shrine
         end
 
         uploader.opts[:mime_type_analyzer] = opts.fetch(:analyzer, uploader.opts.fetch(:mime_type_analyzer, :file))
+        uploader.opts[:mime_type_analyzer_options] = opts.fetch(:analyzer_options, uploader.opts.fetch(:mime_type_analyzer_options, {}))
       end
 
       module ClassMethods
@@ -20,8 +21,13 @@ class Shrine
         # analyzer.
         def determine_mime_type(io)
           analyzer = opts[:mime_type_analyzer]
+
           analyzer = mime_type_analyzer(analyzer) if analyzer.is_a?(Symbol)
-          args     = [io, mime_type_analyzers].take(analyzer.arity.abs)
+          args     = if analyzer.is_a?(Proc)
+              [io, mime_type_analyzers].take(analyzer.arity.abs)
+            else
+              [io, opts[:mime_type_analyzer_options]]
+            end
 
           mime_type = analyzer.call(*args)
           io.rewind
@@ -40,7 +46,7 @@ class Shrine
 
         # Returns callable mime type analyzer object.
         def mime_type_analyzer(name)
-          MimeTypeAnalyzer.new(name).method(:call)
+          MimeTypeAnalyzer.new(name)
         end
       end
 
@@ -68,8 +74,8 @@ class Shrine
           @tool = tool
         end
 
-        def call(io)
-          mime_type = send(:"extract_with_#{@tool}", io)
+        def call(io, options = {})
+          mime_type = send(:"extract_with_#{@tool}", io, options)
           io.rewind
 
           mime_type
@@ -77,7 +83,7 @@ class Shrine
 
         private
 
-        def extract_with_file(io)
+        def extract_with_file(io, options)
           require "open3"
 
           return nil if io.eof? # file command returns "application/x-empty" for empty files
@@ -106,14 +112,14 @@ class Shrine
           raise Error, "file command-line tool is not installed"
         end
 
-        def extract_with_fastimage(io)
+        def extract_with_fastimage(io, options)
           require "fastimage"
 
           type = FastImage.type(io)
           "image/#{type}" if type
         end
 
-        def extract_with_filemagic(io)
+        def extract_with_filemagic(io, options)
           require "filemagic"
 
           return nil if io.eof? # FileMagic returns "application/x-empty" for empty files
@@ -123,22 +129,23 @@ class Shrine
           end
         end
 
-        def extract_with_mimemagic(io)
+        def extract_with_mimemagic(io, options)
           require "mimemagic"
 
           mime = MimeMagic.by_magic(io)
           mime.type if mime
         end
 
-        def extract_with_marcel(io)
+        def extract_with_marcel(io, options)
           require "marcel"
 
           return nil if io.eof? # marcel returns "application/octet-stream" for empty files
 
-          Marcel::MimeType.for(io, name: extract_filename(io))
+          filename = (options[:filename_fallback] ? extract_filename(io) : nil)
+          Marcel::MimeType.for(io, name: filename)
         end
 
-        def extract_with_mime_types(io)
+        def extract_with_mime_types(io, options)
           require "mime/types"
 
           if filename = extract_filename(io)
@@ -147,7 +154,7 @@ class Shrine
           end
         end
 
-        def extract_with_mini_mime(io)
+        def extract_with_mini_mime(io, options)
           require "mini_mime"
 
           if filename = extract_filename(io)
@@ -156,7 +163,7 @@ class Shrine
           end
         end
 
-        def extract_with_content_type(io)
+        def extract_with_content_type(io, options)
           if io.respond_to?(:content_type) && io.content_type
             io.content_type.split(";").first
           end

data/lib/shrine/plugins/download_endpoint.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "roda"
-
 class Shrine
   module Plugins
     # Documentation lives in [doc/plugins/download_endpoint.md] on GitHub.
@@ -14,14 +12,10 @@ class Shrine
       end
 
       def self.configure(uploader, opts = {})
-        uploader.opts[:download_endpoint_storages] = opts.fetch(:storages, uploader.opts[:download_endpoint_storages])
-        uploader.opts[:download_endpoint_prefix] = opts.fetch(:prefix, uploader.opts[:download_endpoint_prefix])
-        uploader.opts[:download_endpoint_download_options] = opts.fetch(:download_options, uploader.opts.fetch(:download_endpoint_download_options, {}))
-        uploader.opts[:download_endpoint_disposition] = opts.fetch(:disposition, uploader.opts.fetch(:download_endpoint_disposition, "inline"))
-        uploader.opts[:download_endpoint_host] = opts.fetch(:host, uploader.opts[:download_endpoint_host])
-        uploader.opts[:download_endpoint_redirect] = opts.fetch(:redirect, uploader.opts.fetch(:download_endpoint_redirect, false))
+        uploader.opts[:download_endpoint] ||= { disposition: "inline", download_options: {} }
+        uploader.opts[:download_endpoint].merge!(opts)
 
-        Shrine.deprecation("The :storages download_endpoint option is deprecated, you should use UploadedFile#download_url for generating URLs to the download endpoint.") if uploader.opts[:download_endpoint_storages]
+        Shrine.deprecation("The :storages download_endpoint option is deprecated, you should use UploadedFile#download_url for generating URLs to the download endpoint.") if uploader.opts[:download_endpoint][:storages]
 
         uploader.assign_download_endpoint(App) unless uploader.const_defined?(:DownloadEndpoint)
       end
@@ -34,13 +28,13 @@ class Shrine
         end
 
         # Returns the Rack application that retrieves requested files.
-        def download_endpoint
-          new_download_endpoint(App)
+        def download_endpoint(**options)
+          new_download_endpoint(App, **options)
         end
 
         # Assigns the subclassed endpoint as the `DownloadEndpoint` constant.
-        def assign_download_endpoint(klass)
-          @download_endpoint = new_download_endpoint(klass)
+        def assign_download_endpoint(app_class)
+          @download_endpoint = new_download_endpoint(app_class)
 
           const_set(:DownloadEndpoint, @download_endpoint)
           deprecate_constant(:DownloadEndpoint)
@@ -48,13 +42,12 @@ class Shrine
 
         private
 
-        def new_download_endpoint(klass)
-          endpoint_class = Class.new(klass)
-          endpoint_class.opts[:shrine_class] = self
-          endpoint_class.opts[:download_options] = opts[:download_endpoint_download_options]
-          endpoint_class.opts[:disposition]      = opts[:download_endpoint_disposition]
-          endpoint_class.opts[:redirect]         = opts[:download_endpoint_redirect]
-          endpoint_class
+        def new_download_endpoint(app_class, **options)
+          app_class.new(
+            shrine_class: self,
+            **opts[:download_endpoint],
+            **options,
+          )
         end
       end
 
@@ -79,7 +72,7 @@ class Shrine
         private
 
         def download_storages
-          shrine_class.opts[:download_endpoint_storages]
+          shrine_class.opts[:download_endpoint][:storages]
         end
       end
 
@@ -101,88 +94,110 @@ class Shrine
         end
 
         def host
-          shrine_class.opts[:download_endpoint_host]
+          options[:host]
         end
 
         def prefix
-          shrine_class.opts[:download_endpoint_prefix]
+          options[:prefix]
         end
 
-        def shrine_class
-          file.shrine_class
+        def options
+          file.shrine_class.opts[:download_endpoint]
         end
       end
 
       # Routes incoming requests. It first asserts that the storage is existent
       # and allowed. Afterwards it proceeds with the file download using
       # streaming.
-      class App < Roda
-        route do |r|
-          # handle legacy ":storage/:id" URLs
-          r.on storage_names do |storage_name|
-            r.get /(.*)/ do |id|
-              uploaded_file = shrine_class::UploadedFile.new(
-                "id"       => id,
-                "storage"  => storage_name,
-              )
-
-              serve_file(uploaded_file)
-            end
+      class App
+        # Writes given options to instance variables.
+        def initialize(options)
+          options.each do |name, value|
+            instance_variable_set("@#{name}", value)
           end
+        end
+
+        def call(env)
+          request = Rack::Request.new(env)
 
-          r.get /(.*)/ do |serialized|
-            uploaded_file = get_uploaded_file(serialized)
-            serve_file(uploaded_file)
+          status, headers, body = catch(:halt) do
+            error!(405, "Method Not Allowed") unless request.get?
+
+            handle_request(request)
           end
+
+          headers["Content-Length"] ||= body.map(&:bytesize).inject(0, :+).to_s
+
+          [status, headers, body]
         end
 
+        def inspect
+          "#<#{@shrine_class}::DownloadEndpoint>"
+        end
+        alias to_s inspect
+
         private
 
+        def handle_request(request)
+          _, *components = request.path_info.split("/")
+
+          if components.count == 1
+            uploaded_file = get_uploaded_file(components.first)
+          elsif components.count == 2
+            # handle legacy "/:storage/:id" URLs
+            uploaded_file = @shrine_class::UploadedFile.new(
+              "storage" => components.first,
+              "id"      => components.last,
+            )
+          end
+
+          serve_file(uploaded_file, request)
+        end
+
         # Streams or redirects to the uploaded file.
-        def serve_file(uploaded_file)
-          if redirect
-            redirect_to_file(uploaded_file)
+        def serve_file(uploaded_file, request)
+          if @redirect
+            redirect_to_file(uploaded_file, request)
           else
-            stream_file(uploaded_file)
+            stream_file(uploaded_file, request)
           end
         end
 
         # Streams the uploaded file content.
-        def stream_file(uploaded_file)
-          open_file(uploaded_file)
+        def stream_file(uploaded_file, request)
+          open_file(uploaded_file, request)
 
           response = uploaded_file.to_rack_response(
-            disposition: disposition,
-            range:       env["HTTP_RANGE"],
+            disposition: @disposition,
+            range:       request.env["HTTP_RANGE"],
           )
 
           response[1]["Cache-Control"] = "max-age=#{365*24*60*60}" # cache for a year
 
-          request.halt response
+          response
         end
 
         # Redirects to the uploaded file's direct URL or the specified URL proc.
-        def redirect_to_file(uploaded_file)
-          if redirect == true
+        def redirect_to_file(uploaded_file, request)
+          if @redirect == true
             redirect_url = uploaded_file.url
           else
-            redirect_url = redirect.call(uploaded_file, request)
+            redirect_url = @redirect.call(uploaded_file, request)
           end
 
-          request.redirect redirect_url
+          [302, { "Location" => redirect_url }, []]
         end
 
-        def open_file(uploaded_file)
-          if download_options.respond_to?(:call)
-            uploaded_file.open(**download_options.call(uploaded_file, request))
-          else
-            uploaded_file.open(**download_options)
-          end
+        def open_file(uploaded_file, request)
+          download_options = @download_options
+          download_options = download_options.call(uploaded_file, request) if download_options.respond_to?(:call)
+
+          uploaded_file.open(**download_options)
         end
 
         # Returns a Shrine::UploadedFile, or returns 404 if file doesn't exist.
         def get_uploaded_file(serialized)
-          uploaded_file = shrine_class::UploadedFile.urlsafe_load(serialized)
+          uploaded_file = @shrine_class::UploadedFile.urlsafe_load(serialized)
           not_found! unless uploaded_file.exists?
           uploaded_file
         rescue Shrine::Error # storage not found
@@ -195,30 +210,7 @@ class Shrine
 
         # Halts the request with the error message.
         def error!(status, message)
-          response.status = status
-          response["Content-Type"] = "text/plain"
-          response.write(message)
-          request.halt
-        end
-
-        def download_options
-          opts[:download_options]
-        end
-
-        def redirect
-          opts[:redirect]
-        end
-
-        def disposition
-          opts[:disposition]
-        end
-
-        def shrine_class
-          opts[:shrine_class]
-        end
-
-        def storage_names
-          shrine_class.storages.keys.map(&:to_s)
+          throw :halt, [status, { "Content-Type" => "text/plain" }, [message]]
         end
       end
     end