shrine 2.19.3 → 3.6.0

data/lib/shrine/plugins/determine_mime_type.rb

@@ -2,9 +2,7 @@
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/determine_mime_type.md] on GitHub.
-    #
-    # [doc/plugins/determine_mime_type.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/determine_mime_type.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/determine_mime_type
     module DetermineMimeType
       LOG_SUBSCRIBER = -> (event) do
         Shrine.logger.info "MIME Type (#{event.duration}ms) – #{{
@@ -13,19 +11,12 @@ class Shrine
         }.inspect}"
       end
 
-      def self.configure(uploader, opts = {})
-        if opts[:analyzer] == :default
-          Shrine.deprecation("The :default analyzer of the determine_mime_type plugin has been renamed to :content_type. The :default alias will not be supported in Shrine 3.")
-          opts = opts.merge(analyzer: :content_type)
-        end
-
-        uploader.opts[:determine_mime_type] ||= { analyzer: :file, analyzer_options: {}, log_subscriber: LOG_SUBSCRIBER }
+      def self.configure(uploader, log_subscriber: LOG_SUBSCRIBER, **opts)
+        uploader.opts[:determine_mime_type] ||= { analyzer: :file, analyzer_options: {} }
         uploader.opts[:determine_mime_type].merge!(opts)
 
         # instrumentation plugin integration
-        if uploader.respond_to?(:subscribe)
-          uploader.subscribe(:mime_type, &uploader.opts[:determine_mime_type][:log_subscriber])
-        end
+        uploader.subscribe(:mime_type, &log_subscriber) if uploader.respond_to?(:subscribe)
       end
 
       module ClassMethods
@@ -79,11 +70,6 @@ class Shrine
         def extract_mime_type(io)
           self.class.determine_mime_type(io)
         end
-
-        # Returns a hash of built-in MIME type analyzers.
-        def mime_type_analyzers
-          self.class.mime_type_analyzers
-        end
       end
 
       class MimeTypeAnalyzer
@@ -138,6 +124,8 @@ class Shrine
           require "fastimage"
 
           type = FastImage.type(io)
+          return 'image/svg+xml' if type == :svg
+
           "image/#{type}" if type
         end
 
@@ -155,7 +143,7 @@ class Shrine
           require "mimemagic"
 
           mime = MimeMagic.by_magic(io)
-          mime.type if mime
+          mime&.type
         end
 
         def extract_with_marcel(io, options)
@@ -172,7 +160,7 @@ class Shrine
 
           if filename = extract_filename(io)
             mime_type = MIME::Types.of(filename).first
-            mime_type.content_type if mime_type
+            mime_type&.content_type
           end
         end
 
@@ -181,7 +169,7 @@ class Shrine
 
           if filename = extract_filename(io)
             info = MiniMime.lookup_by_filename(filename)
-            info.content_type if info
+            info&.content_type
           end
         end
 

data/lib/shrine/plugins/download_endpoint.rb

@@ -2,78 +2,60 @@
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/download_endpoint.md] on GitHub.
-    #
-    # [doc/plugins/download_endpoint.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/download_endpoint.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/download_endpoint
     module DownloadEndpoint
-      def self.load_dependencies(uploader, opts = {})
+      def self.load_dependencies(uploader, **)
         uploader.plugin :rack_response
         uploader.plugin :_urlsafe_serialization
       end
 
-      def self.configure(uploader, opts = {})
+      def self.configure(uploader, **opts)
         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]
-
-        uploader.assign_download_endpoint(App) unless uploader.const_defined?(:DownloadEndpoint)
       end
 
       module ClassMethods
-        # Assigns the subclass a copy of the download endpoint class.
-        def inherited(subclass)
-          super
-          subclass.assign_download_endpoint(@download_endpoint)
-        end
-
         # Returns the Rack application that retrieves requested files.
         def download_endpoint(**options)
-          new_download_endpoint(App, **options)
-        end
-
-        # Assigns the subclassed endpoint as the `DownloadEndpoint` constant.
-        def assign_download_endpoint(app_class)
-          @download_endpoint = new_download_endpoint(app_class)
-
-          const_set(:DownloadEndpoint, @download_endpoint)
-          deprecate_constant(:DownloadEndpoint)
-        end
-
-        private
-
-        def new_download_endpoint(app_class, **options)
-          app_class.new(
+          Shrine::DownloadEndpoint.new(
             shrine_class: self,
             **opts[:download_endpoint],
             **options,
           )
         end
-      end
 
-      module FileMethods
-        # Constructs the URL from the optional host, prefix, storage key and
-        # uploaded file's id. For other uploaded files that aren't in the list
-        # of storages it just returns their original URL.
-        def url(**options)
-          if download_storages && download_storages.include?(storage_key.to_sym)
-            Shrine.deprecation("The :storages option for download_endpoint plugin is deprecated and will be obsolete in Shrine 3. Use UploadedFile#download_url instead.")
-            download_url
-          else
-            super
+        # Calls the download endpoint passing the request information, and
+        # returns the Rack response triple.
+        #
+        # It uses a trick where it removes the download path prefix from the
+        # path info before calling the Rack app, which is what web framework
+        # routers do before they're calling a mounted Rack app.
+        def download_response(env, **options)
+          script_name = env["SCRIPT_NAME"]
+          path_info   = env["PATH_INFO"]
+
+          prefix = opts[:download_endpoint][:prefix]
+          match  = path_info.match(/^\/#{prefix}/)
+
+          fail Error, "request path must start with \"/#{prefix}\", but is \"#{path_info}\"" unless match
+
+          begin
+            env["SCRIPT_NAME"] += match.to_s
+            env["PATH_INFO"]    = match.post_match
+
+            download_endpoint(**options).call(env)
+          ensure
+            env["SCRIPT_NAME"] = script_name
+            env["PATH_INFO"]   = path_info
           end
         end
+      end
 
+      module FileMethods
         # Returns file URL on the download endpoint.
         def download_url(**options)
           FileUrl.new(self).call(**options)
         end
-
-        private
-
-        def download_storages
-          shrine_class.opts[:download_endpoint][:storages]
-        end
       end
 
       class FileUrl
@@ -105,116 +87,119 @@ class Shrine
           file.shrine_class.opts[:download_endpoint]
         end
       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
-        # Writes given options to instance variables.
-        def initialize(options)
-          options.each do |name, value|
-            instance_variable_set("@#{name}", value)
-          end
-        end
+    register_plugin(:download_endpoint, DownloadEndpoint)
+  end
 
-        def call(env)
-          request = Rack::Request.new(env)
 
-          status, headers, body = catch(:halt) do
-            error!(405, "Method Not Allowed") unless request.get?
+  # Routes incoming requests. It first asserts that the storage is existent
+  # and allowed. Afterwards it proceeds with the file download using
+  # streaming.
+  class DownloadEndpoint
+    # Writes given options to instance variables.
+    def initialize(options)
+      options.each do |name, value|
+        instance_variable_set("@#{name}", value)
+      end
+    end
 
-            handle_request(request)
-          end
+    def call(env)
+      request = Rack::Request.new(env)
 
-          headers["Content-Length"] ||= body.map(&:bytesize).inject(0, :+).to_s
+      status, headers, body = catch(:halt) do
+        error!(405, "Method Not Allowed") unless request.get?
 
-          [status, headers, body]
-        end
+        handle_request(request)
+      end
 
-        def inspect
-          "#<#{@shrine_class}::DownloadEndpoint>"
-        end
-        alias to_s inspect
+      headers = Rack::Headers[headers] if Rack.release >= "3"
+      headers["Content-Length"] ||= body.respond_to?(:bytesize) ? body.bytesize.to_s :
+                                                                  body.map(&:bytesize).inject(0, :+).to_s
 
-        private
+      [status, headers, body]
+    end
 
-        def handle_request(request)
-          _, *components = request.path_info.split("/")
+    def inspect
+      "#<#{@shrine_class}::DownloadEndpoint>"
+    end
+    alias to_s inspect
 
-          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
+    private
 
-          serve_file(uploaded_file, request)
-        end
+    def handle_request(request)
+      _, serialized, * = request.path_info.split("/")
 
-        # Streams or redirects to the uploaded file.
-        def serve_file(uploaded_file, request)
-          if @redirect
-            redirect_to_file(uploaded_file, request)
-          else
-            stream_file(uploaded_file, request)
-          end
-        end
+      uploaded_file = get_uploaded_file(serialized)
 
-        # Streams the uploaded file content.
-        def stream_file(uploaded_file, request)
-          open_file(uploaded_file, request)
+      serve_file(uploaded_file, request)
+    end
 
-          response = uploaded_file.to_rack_response(
-            disposition: @disposition,
-            range:       request.env["HTTP_RANGE"],
-          )
+    # Streams or redirects to the uploaded file.
+    def serve_file(uploaded_file, request)
+      if @redirect
+        redirect_to_file(uploaded_file, request)
+      else
+        stream_file(uploaded_file, request)
+      end
+    end
 
-          response[1]["Cache-Control"] = "max-age=#{365*24*60*60}" # cache for a year
+    # Streams the uploaded file content.
+    def stream_file(uploaded_file, request)
+      open_file(uploaded_file, request)
 
-          response
-        end
+      response = uploaded_file.to_rack_response(
+        disposition: @disposition,
+        range:       request.env["HTTP_RANGE"],
+      )
 
-        # Redirects to the uploaded file's direct URL or the specified URL proc.
-        def redirect_to_file(uploaded_file, request)
-          if @redirect == true
-            redirect_url = uploaded_file.url
-          else
-            redirect_url = @redirect.call(uploaded_file, request)
-          end
+      response[1]["Cache-Control"] = "max-age=#{365*24*60*60}" # cache for a year
 
-          [302, { "Location" => redirect_url }, []]
-        end
+      response
+    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)
+    # Redirects to the uploaded file's direct URL or the specified URL proc.
+    def redirect_to_file(uploaded_file, request)
+      if @redirect == true
+        redirect_url = uploaded_file.url
+      else
+        redirect_url = @redirect.call(uploaded_file, request)
+      end
 
-          uploaded_file.open(**download_options)
-        end
+      [302, { "Location" => redirect_url }, []]
+    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)
-          not_found! unless uploaded_file.exists?
-          uploaded_file
-        rescue Shrine::Error # storage not found
-          not_found!
-        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)
 
-        def not_found!
-          error!(404, "File Not Found")
-        end
+      uploaded_file.open(**download_options)
+    rescue Shrine::FileNotFound
+      not_found!
+    end
 
-        # Halts the request with the error message.
-        def error!(status, message)
-          throw :halt, [status, { "Content-Type" => "text/plain" }, [message]]
-        end
-      end
+    # Deserializes a Shrine::UploadedFile from a URL component. Returns 404 if
+    # storage is not found.
+    def get_uploaded_file(serialized)
+      @shrine_class::UploadedFile.urlsafe_load(serialized)
+    rescue Shrine::Error # storage not found
+      not_found!
+    rescue JSON::ParserError, ArgumentError => error # invalid serialized component
+      raise if error.is_a?(ArgumentError) && error.message != "invalid base64"
+      bad_request!("Invalid serialized file")
     end
 
-    register_plugin(:download_endpoint, DownloadEndpoint)
+    def not_found!
+      error!(404, "File Not Found")
+    end
+
+    def bad_request!(message)
+      error!(400, message)
+    end
+
+    # Halts the request with the error message.
+    def error!(status, message)
+      throw :halt, [status, { "Content-Type" => "text/plain" }, [message]]
+    end
   end
 end

data/lib/shrine/plugins/dynamic_storage.rb

@@ -2,21 +2,15 @@
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/dynamic_storage.md] on GitHub.
-    #
-    # [doc/plugins/dynamic_storage.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/dynamic_storage.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/dynamic_storage
     module DynamicStorage
-      def self.configure(uploader, options = {})
-        uploader.opts[:dynamic_storages] ||= {}
+      def self.configure(uploader)
+        uploader.opts[:dynamic_storage] ||= { resolvers: {} }
       end
 
       module ClassMethods
-        def dynamic_storages
-          opts[:dynamic_storages]
-        end
-
         def storage(regex, &block)
-          dynamic_storages[regex] = block
+          opts[:dynamic_storage][:resolvers][regex] = block
         end
 
         def find_storage(name)
@@ -26,7 +20,7 @@ class Shrine
         private
 
         def resolve_dynamic_storage(name)
-          dynamic_storages.each do |regex, block|
+          opts[:dynamic_storage][:resolvers].each do |regex, block|
             if match = name.to_s.match(regex)
               return block.call(match)
             end

data/lib/shrine/plugins/entity.rb

@@ -0,0 +1,158 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # Documentation can be found on https://shrinerb.com/docs/plugins/entity
+    module Entity
+      def self.load_dependencies(uploader, **)
+        uploader.plugin :column
+      end
+
+      module AttachmentMethods
+        # Defines instance methods on initialization.
+        def initialize(name, **options)
+          super
+
+          define_entity_methods(name)
+        end
+
+        # Defines class methods on inclusion.
+        def included(klass)
+          super
+
+          attachment = self
+
+          klass.send(:define_singleton_method, :"#{@name}_attacher") do |**options|
+            attachment.send(:class_attacher, **options)
+          end
+        end
+
+        private
+
+        # Defines `#<name>`, `#<name>_url`, and `#<name>_attacher` methods.
+        def define_entity_methods(name)
+          super if defined?(super)
+
+          attachment = self
+
+          # Returns the attached file.
+          if shrine_class::Attacher.instance_method(:get).arity == 0
+            define_method :"#{name}" do
+              send(:"#{name}_attacher").get
+            end
+          else # derivatives
+            define_method :"#{name}" do |*args|
+              send(:"#{name}_attacher").get(*args)
+            end
+          end
+
+          # Returns the URL to the attached file.
+          define_method :"#{name}_url" do |*args, **options|
+            send(:"#{name}_attacher").url(*args, **options)
+          end
+
+          # Returns an attacher instance.
+          define_method :"#{name}_attacher" do |**options|
+            attachment.send(:attacher, self, **options)
+          end
+        end
+
+        # Returns the class attacher instance with loaded entity. It's not
+        # memoized because the entity object could be frozen.
+        def attacher(record, **options)
+          attacher = class_attacher(**options)
+          attacher.load_entity(record, @name)
+          attacher
+        end
+
+        # Creates an instance of the corresponding attacher class with set
+        # name.
+        def class_attacher(**options)
+          attacher = shrine_class::Attacher.new(**@options, **options)
+          attacher.instance_variable_set(:@name, @name)
+          attacher
+        end
+      end
+
+      module AttacherClassMethods
+        # Initializes itself from an entity instance and attachment name.
+        #
+        #     photo.image_data #=> "{...}" # a file is attached
+        #
+        #     attacher = Attacher.from_entity(photo, :image)
+        #     attacher.file #=> #<Shrine::UploadedFile>
+        def from_entity(record, name, **options)
+          attacher = new(**options)
+          attacher.load_entity(record, name)
+          attacher
+        end
+      end
+
+      module AttacherMethods
+        attr_reader :record, :name
+
+        # Saves record and name and initializes attachment from the entity
+        # attribute. Called from `Attacher.from_entity`.
+        def load_entity(record, name)
+          set_entity(record, name)
+          read
+        end
+
+        # Sets record and name without loading the attachment from the entity
+        # attribute.
+        def set_entity(record, name)
+          @record = record
+          @name   = name.to_sym
+
+          @context.merge!(record: record, name: name)
+        end
+
+        # Overwrites the current attachment with the one from model attribute.
+        #
+        #     photo.image_data #=> nil
+        #     attacher = Shrine::Attacher.from_entity(photo, :image)
+        #     photo.image_data = uploaded_file.to_json
+        #
+        #     attacher.file #=> nil
+        #     attacher.reload
+        #     attacher.file #=> #<Shrine::UploadedFile>
+        def reload
+          read
+          @previous = nil
+          self
+        end
+
+        # Loads attachment from the entity attribute.
+        def read
+          load_column(read_attribute)
+        end
+
+        # Returns a hash with entity attribute name and column data.
+        #
+        #     attacher.column_values
+        #     #=> { image_data: '{"id":"...","storage":"...","metadata":{...}}' }
+        def column_values
+          { attribute => column_data }
+        end
+
+        # Returns the entity attribute name used for reading and writing
+        # attachment data.
+        #
+        #     attacher = Shrine::Attacher.from_entity(photo, :image)
+        #     attacher.attribute #=> :image_data
+        def attribute
+          :"#{name}_data" if name
+        end
+
+        private
+
+        # Reads value from the entity attribute.
+        def read_attribute
+          record.public_send(attribute)
+        end
+      end
+    end
+
+    register_plugin(:entity, Entity)
+  end
+end