shrine 2.19.4 → 3.0.0.alpha

data/lib/shrine/plugins/determine_mime_type.rb

@@ -13,19 +13,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 +72,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

data/lib/shrine/plugins/download_endpoint.rb

@@ -6,44 +6,20 @@ class Shrine
     #
     # [doc/plugins/download_endpoint.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/download_endpoint.md
     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,
@@ -52,28 +28,10 @@ class Shrine
       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
-          end
-        end
-
         # 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 +63,110 @@ 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["Content-Length"] ||= 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!
     end
 
-    register_plugin(:download_endpoint, DownloadEndpoint)
+    def not_found!
+      error!(404, "File Not Found")
+    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

@@ -6,17 +6,13 @@ class Shrine
     #
     # [doc/plugins/dynamic_storage.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/dynamic_storage.md
     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 +22,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,128 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # Documentation lives in [doc/plugins/entity.md] on GitHub.
+    #
+    # [doc/plugins/entity.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/entity.md
+    module Entity
+      def self.load_dependencies(uploader, **)
+        uploader.plugin :column
+      end
+
+      module AttachmentMethods
+        # Defines `#<name>`, `#<name>_url`, and `#<name>_attacher` methods.
+        def initialize(name, **options)
+          super
+
+          attachment = self
+
+          # Returns the attached file.
+          define_method :"#{name}" do |*args|
+            send(:"#{name}_attacher").get(*args)
+          end
+
+          # Returns the URL to the attached file.
+          define_method :"#{name}_url" do |*args|
+            send(:"#{name}_attacher").url(*args)
+          end
+
+          # Returns an attacher instance.
+          define_method :"#{name}_attacher" do |**options|
+            attachment.attacher(self, options)
+          end
+        end
+
+        # Creates an instance of the corresponding Attacher subclass. It's not
+        # memoized because the entity object could be frozen.
+        def attacher(record, options)
+          shrine_class::Attacher.from_entity(record, @name, @options.merge(options))
+        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, type: :entity, **options)
+          attacher = new(**options)
+          attacher.load_entity(record, name, type: type)
+          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, type: :entity)
+          @record = record
+          @name   = name.to_sym
+          @type   = type
+
+          @context.merge!(record: record, name: name)
+
+          read
+        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
+          self
+        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
+          fail Shrine::Error, "record is not loaded" if name.nil?
+
+          :"#{name}_data"
+        end
+
+        private
+
+        # Loads attachment from the entity attribute.
+        def read
+          load_column(read_attribute)
+        end
+
+        # Reads value from the entity attribute.
+        def read_attribute
+          record.public_send(attribute)
+        end
+
+        # Returns whether the attacher has been loaded from an entity instance.
+        def entity?
+          type == :entity
+        end
+
+        attr_reader :type
+      end
+    end
+
+    register_plugin(:entity, Entity)
+  end
+end