shrine 2.19.4 → 3.0.0.alpha

data/lib/shrine/plugins/default_storage.rb

@@ -6,24 +6,30 @@ class Shrine
     #
     # [doc/plugins/default_storage.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/default_storage.md
     module DefaultStorage
-      def self.configure(uploader, opts = {})
-        uploader.opts[:default_storage_cache] = opts.fetch(:cache, uploader.opts[:default_storage_cache])
-        uploader.opts[:default_storage_store] = opts.fetch(:store, uploader.opts[:default_storage_store])
+      def self.configure(uploader, **opts)
+        uploader.opts[:default_storage] ||= {}
+        uploader.opts[:default_storage].merge!(opts)
       end
 
       module AttacherMethods
-        def initialize(record, name, **options)
-          if cache = shrine_class.opts[:default_storage_cache]
-            cache = cache.call(record, name) if cache.respond_to?(:call)
-            options[:cache] = cache
-          end
+        def initialize(**options)
+          super(**shrine_class.opts[:default_storage], **options)
+        end
 
-          if store = shrine_class.opts[:default_storage_store]
-            store = store.call(record, name) if store.respond_to?(:call)
-            options[:store] = store
+        def cache_key
+          if @cache.respond_to?(:call)
+            @cache.call(record, name)
+          else
+            @cache
           end
+        end
 
-          super
+        def store_key
+          if @store.respond_to?(:call)
+            @store.call(record, name)
+          else
+            @store
+          end
         end
       end
     end

data/lib/shrine/plugins/default_url.rb

@@ -6,18 +6,14 @@ class Shrine
     #
     # [doc/plugins/default_url.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/default_url.md
     module DefaultUrl
-      def self.configure(uploader, opts = {}, &block)
-        uploader.opts[:default_url_host] = opts.fetch(:host, uploader.opts[:default_url_host])
-
-        if block
-          uploader.opts[:default_url] = block
-          Shrine.deprecation("Passing a block to default_url plugin is deprecated and will probably be removed in future versions of Shrine. Use `Attacher.default_url { ... }` instead.")
-        end
+      def self.configure(uploader, **opts)
+        uploader.opts[:default_url] ||= {}
+        uploader.opts[:default_url].merge!(opts)
       end
 
       module AttacherClassMethods
         def default_url(&block)
-          shrine_class.opts[:default_url_block] = block
+          shrine_class.opts[:default_url][:block] = block
         end
       end
 
@@ -29,25 +25,19 @@ class Shrine
         private
 
         def default_url(**options)
-          url = if default_url_block
-                  instance_exec(options, &default_url_block)
-                elsif shrine_class.opts[:default_url]
-                  shrine_class.opts[:default_url].call(context.merge(options){|k, old, new| old})
-                end
-
-          if default_url_host
-            [default_url_host, url].join
-          else
-            url
-          end
+          return unless default_url_block
+
+          url = instance_exec(options, &default_url_block)
+
+          [*default_url_host, url].join
         end
 
         def default_url_block
-          shrine_class.opts[:default_url_block]
+          shrine_class.opts[:default_url][:block]
         end
 
         def default_url_host
-          shrine_class.opts[:default_url_host]
+          shrine_class.opts[:default_url][:host]
         end
       end
     end

data/lib/shrine/plugins/default_url_options.rb

@@ -1,34 +1,7 @@
 # frozen_string_literal: true
 
-class Shrine
-  module Plugins
-    # Documentation lives in [doc/plugins/default_url_options.md] on GitHub.
-    #
-    # [doc/plugins/default_url_options.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/default_url_options.md
-    module DefaultUrlOptions
-      def self.configure(uploader, options = {})
-        uploader.opts[:default_url_options] ||= {}
-        uploader.opts[:default_url_options].merge!(options)
-      end
+Shrine.deprecation("The default_url_options plugin has been renamed to url_options, so `plugin :default_url_options` should be replaced with `plugin :url_options`. The default_url_options alias will be removed in Shrine 4.")
 
-      module FileMethods
-        def url(**options)
-          default_options   = default_url_options
-          default_options   = default_options.call(self, options) if default_options.respond_to?(:call)
-          default_options ||= {}
+require "shrine/plugins/url_options"
 
-          super(default_options.merge(options))
-        end
-
-        private
-
-        def default_url_options
-          options = shrine_class.opts[:default_url_options]
-          options[storage_key.to_sym]
-        end
-      end
-    end
-
-    register_plugin(:default_url_options, DefaultUrlOptions)
-  end
-end
+Shrine::Plugins.register_plugin(:default_url_options, Shrine::Plugins::UrlOptions)

data/lib/shrine/plugins/delete_raw.rb

@@ -1,33 +1,29 @@
 # frozen_string_literal: true
 
+Shrine.deprecation("The delete_raw plugin is deprecated and will be removed in Shrine 4. If you were using it with versions plugin, use the new derivatives plugin instead.")
+
 class Shrine
   module Plugins
     # Documentation lives in [doc/plugins/delete_raw.md] on GitHub.
     #
     # [doc/plugins/delete_raw.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/delete_raw.md
     module DeleteRaw
-      def self.configure(uploader, opts = {})
-        uploader.opts[:delete_raw_storages] = opts.fetch(:storages, uploader.opts[:delete_raw_storages])
+      def self.configure(uploader, **opts)
+        uploader.opts[:delete_raw] ||= {}
+        uploader.opts[:delete_raw].merge!(opts)
       end
 
       module InstanceMethods
         private
 
         # Deletes the file that was uploaded, unless it's an UploadedFile.
-        def copy(io, context)
-          super
-          if io.respond_to?(:path) && io.path && delete_raw? && context[:delete] != false
-            begin
-              File.delete(io.path)
-            rescue Errno::ENOENT
-              # file might already be deleted by the moving plugin
-            end
-          end
+        def _upload(io, delete: delete_raw?, **options)
+          super(io, delete: delete, **options)
         end
 
         def delete_raw?
-          opts[:delete_raw_storages].nil? ||
-          opts[:delete_raw_storages].include?(storage_key)
+          opts[:delete_raw][:storages].nil? ||
+          opts[:delete_raw][:storages].include?(storage_key)
         end
       end
     end

data/lib/shrine/plugins/derivation_endpoint.rb

@@ -5,6 +5,7 @@ require "content_disposition"
 
 require "openssl"
 require "tempfile"
+require "pathname"
 
 class Shrine
   module Plugins
@@ -20,25 +21,21 @@ class Shrine
         }.inspect}"
       end
 
-      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 = {})
-        uploader.opts[:derivation_endpoint_options] ||= { log_subscriber: LOG_SUBSCRIBER }
-        uploader.opts[:derivation_endpoint_options].merge!(opts)
+      def self.configure(uploader, log_subscriber: LOG_SUBSCRIBER, **opts)
+        uploader.opts[:derivation_endpoint] ||= { options: {}, derivations: {} }
+        uploader.opts[:derivation_endpoint][:options].merge!(opts)
 
-        uploader.opts[:derivation_endpoint_derivations] ||= {}
-
-        unless uploader.opts[:derivation_endpoint_options][:secret_key]
+        unless uploader.opts[:derivation_endpoint][:options][:secret_key]
           fail Error, "must provide :secret_key option to derivation_endpoint plugin"
         end
 
         # instrumentation plugin integration
-        if uploader.respond_to?(:subscribe)
-          uploader.subscribe(:derivation, &uploader.opts[:derivation_endpoint_options][:log_subscriber])
-        end
+        uploader.subscribe(:derivation, &log_subscriber) if uploader.respond_to?(:subscribe)
       end
 
       module ClassMethods
@@ -76,15 +73,15 @@ class Shrine
         # Registers a derivation block, which is called when the corresponding
         # derivation URL is requested.
         def derivation(name, &block)
-          derivations[name] = block
+          derivations[name.to_sym] = block
         end
 
         def derivations
-          opts[:derivation_endpoint_derivations]
+          opts[:derivation_endpoint][:derivations]
         end
 
         def derivation_options
-          opts[:derivation_endpoint_options]
+          opts[:derivation_endpoint][:options]
         end
       end
 
@@ -127,7 +124,7 @@ class Shrine
     attr_reader :name, :args, :source, :options
 
     def initialize(name:, args:, source:, options:)
-      @name    = name
+      @name    = name.to_sym
       @args    = args
       @source  = source
       @options = options
@@ -163,16 +160,22 @@ class Shrine
 
     # Uploads the derivation result to a dedicated destination on the specified
     # Shrine storage.
-    def upload(file = nil)
-      Derivation::Upload.new(self).call(file)
+    def upload(file = nil, **options)
+      Derivation::Upload.new(self).call(file, **options)
     end
 
-    # Returns a Shrine::UploadedFile object pointing to the uploaded derivation
-    # result.
+    # Returns a Shrine::UploadedFile object pointing to the uploaded derivative
+    # if it exists.
     def retrieve
       Derivation::Retrieve.new(self).call
     end
 
+    # Returns opened Shrine::UploadedFile object pointing to the uploaded
+    # derivative if it exists.
+    def opened
+      Derivation::Opened.new(self).call
+    end
+
     # Deletes the derivation result from the storage.
     def delete
       Derivation::Delete.new(self).call
@@ -189,12 +192,10 @@ class Shrine
     option :cache_control,               default: -> { default_cache_control }
     option :disposition,                 default: -> { "inline" }
     option :download,                    default: -> { true }
-    option :download_errors,             default: -> { [] }
     option :download_options,            default: -> { {} }
     option :expires_in
     option :filename,                    default: -> { default_filename }
     option :host
-    option :include_uploaded_file,       default: -> { false }
     option :metadata,                    default: -> { [] }
     option :prefix
     option :secret_key
@@ -260,7 +261,7 @@ class Shrine
 
     # The source uploaded file storage is the default derivative storage.
     def default_upload_storage
-      source.storage_key.to_sym
+      source.storage_key
     end
 
     # Allows caching for 1 year or until the URL expires.
@@ -399,10 +400,10 @@ class Shrine
 
       begin
         status, headers, body = derivation.response(request.env)
-      rescue Derivation::NotFound
-        error!(404, "Unknown derivation \"#{name}\"")
       rescue Derivation::SourceNotFound
         error!(404, "Source file not found")
+      rescue Derivation::NotFound
+        error!(404, "Unknown derivation \"#{name}\"")
       end
 
       # tell clients to cache the derivation result if it was successful
@@ -504,28 +505,21 @@ class Shrine
     # uploads the result. If the derivation result is already uploaded, uses
     # the `rack_response` plugin to generate a Rack response triple.
     def upload_response(env)
-      uploaded_file = derivation.retrieve
+      uploaded_file = upload_redirect ? derivation.retrieve : derivation.opened
 
       unless uploaded_file
         derivative    = derivation.generate
-        uploaded_file = derivation.upload(derivative)
+        uploaded_file = derivation.upload(derivative, delete: upload_redirect)
       end
 
       if upload_redirect
-        # we don't need the local derivation result here
-        if derivative
-          derivative.close
-          File.delete(derivative.path)
-        end
-
         redirect_url = uploaded_file.url(upload_redirect_url_options)
 
         [302, { "Location" => redirect_url }, []]
       else
-        if derivative && File.exist?(derivative.path)
+        if derivative
           file_response(derivative, env)
         else
-          uploaded_file.open(**upload_open_options)
           uploaded_file.to_rack_response(
             type:        type,
             disposition: disposition,
@@ -544,8 +538,10 @@ class Shrine
       if Rack.release > "2"
         server.serving(Rack::Request.new(env), path)
       else
+        # :nocov:
         server.path = path
         server.serving(env)
+        # :nocov:
       end
     end
 
@@ -572,9 +568,7 @@ class Shrine
   end
 
   class Derivation::Generate < Derivation::Command
-    delegate :name, :args, :source,
-             :download, :download_errors, :download_options,
-             :include_uploaded_file
+    delegate :name, :args, :source, :download, :download_options
 
     def call(file = nil)
       derivative = generate(file)
@@ -589,22 +583,16 @@ class Shrine
     # file.
     def generate(file)
       if download
-        with_downloaded(file) do |file|
-          if include_uploaded_file
-            derive(file, source, *args)
-          else
-            derive(file, *args)
-          end
-        end
+        with_downloaded(file) { |file| derive(file, *args) }
       else
-        derive(source, *args)
+        derive(*args)
       end
     end
 
     # Calls the derivation block.
     def derive(*args)
       instrument_derivation do
-        uploader.instance_exec(*args, &derivation_block)
+        derivation.instance_exec(*args, &derivation_block)
       end
     end
 
@@ -624,51 +612,35 @@ class Shrine
     # Massages the derivation result, ensuring it's opened in binary mode,
     # rewinded and flushed to disk.
     def normalize(derivative)
-      if derivative.is_a?(Tempfile)
-        derivative.open
-      elsif derivative.is_a?(File)
-        derivative.close
-        derivative = File.open(derivative.path)
-      elsif derivative.is_a?(String)
-        derivative = File.open(derivative)
-      elsif defined?(Pathname) && derivative.is_a?(Pathname)
-        derivative = derivative.open
-      else
-        fail Error, "unexpected derivation result: #{derivation.inspect} (expected File, Tempfile, String, or Pathname object)"
-      end
+      derivative =
+        case derivative
+        when Tempfile         then derivative.tap(&:open)
+        when File             then File.open(derivative.tap(&:close))
+        when String, Pathname then File.open(derivative)
+        else
+          fail Error, "unexpected derivation result: #{derivation.inspect} (expected File, Tempfile, String, or Pathname object)"
+        end
 
       derivative.binmode
       derivative
     end
 
     def with_downloaded(file, &block)
-      if file
-        yield file
-      else
-        download_source(&block)
-      end
+      return yield(file) if file
+
+      download_source(&block)
     end
 
     # Downloads the source uploaded file from the storage.
-    def download_source
-      begin
-        file = source.download(**download_options)
-      rescue *download_errors
-        raise Derivation::SourceNotFound, "source file \"#{source.id}\" was not found on storage :#{source.storage_key}"
-      end
-
-      yield file
-    ensure
-      file.close! if file
+    def download_source(&block)
+      source.download(**download_options, &block)
+    rescue Shrine::FileNotFound
+      raise Derivation::SourceNotFound, "source file \"#{source.id}\" was not found on storage :#{source.storage_key}"
     end
 
     def derivation_block
       shrine_class.derivations[name] or fail Derivation::NotFound, "derivation #{name.inspect} is not defined"
     end
-
-    def uploader
-      source.uploader
-    end
   end
 
   class Derivation::Upload < Derivation::Command
@@ -677,59 +649,48 @@ class Shrine
     # Uploads the derivation result to the dedicated location on the storage.
     # If a file object is given, uploads that to the storage, otherwise calls
     # the derivation block and uploads the result.
-    def call(derivative = nil)
-      with_derivative(derivative) do |uploadable|
-        uploader.upload uploadable,
-          location:       upload_location,
-          upload_options: upload_options
-      end
-    end
-
-    private
-
-    def with_derivative(derivative)
+    def call(derivative = nil, **options)
       if derivative
-        begin
-          # we want to keep the provided file open and rewinded
-          File.open(derivative.path, binmode: true) do |file|
-            yield file
-          end
-        ensure
-          # close the file handler if the file was deleted during upload
-          derivative.close if !File.exist?(derivative.path)
-        end
+        upload(derivative, **options)
       else
-        # generate the derivative and delete it afterwards
-        begin
-          file = derivation.generate
-          yield file
-        ensure
-          file.close
-          File.delete(file.path)
-        end
+        upload(derivation.generate, delete: true, **options)
       end
     end
 
-    def uploader
-      shrine_class.new(upload_storage)
+    private
+
+    def upload(io, **options)
+      shrine_class.upload io, upload_storage,
+        location:       upload_location,
+        upload_options: upload_options,
+        **options
     end
   end
 
   class Derivation::Retrieve < Derivation::Command
-    delegate :upload_location, :upload_storage
+    delegate :upload_storage, :upload_location
 
-    # Returns a Shrine::UploadedFile object pointing to the uploaded derivation
-    # result it exists on the storage.
+    # Returns a Shrine::UploadedFile object pointing to the uploaded derivative
+    # if it exists on the storage.
     def call
-      uploaded_file = shrine_class::UploadedFile.new(
-        "storage" => upload_storage.to_s,
-        "id"      => upload_location,
-      )
-
+      uploaded_file = shrine_class.uploaded_file(storage: upload_storage, id: upload_location)
       uploaded_file if uploaded_file.exists?
     end
   end
 
+  class Derivation::Opened < Derivation::Command
+    delegate :upload_storage, :upload_location, :upload_open_options
+
+    # Returns opened Shrine::UploadedFile object pointing to the uploaded if
+    # it exists on the storage.
+    def call
+      uploaded_file = shrine_class.uploaded_file(storage: upload_storage, id: upload_location)
+      uploaded_file.open(**upload_open_options)
+      uploaded_file
+    rescue Shrine::FileNotFound
+    end
+  end
+
   class Derivation::Delete < Derivation::Command
     delegate :upload_location, :upload_storage