shrine 3.4.0 → 3.10.0

data/lib/shrine/plugins/entity.rb

@@ -10,7 +10,7 @@ class Shrine
 
       module AttachmentMethods
         # Defines instance methods on initialization.
-        def initialize(name, **options)
+        def initialize(name, **)
           super
 
           define_entity_methods(name)
@@ -36,8 +36,14 @@ class Shrine
           attachment = self
 
           # Returns the attached file.
-          define_method :"#{name}" do |*args|
-            send(:"#{name}_attacher").get(*args)
+          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.
@@ -53,16 +59,16 @@ class Shrine
 
         # 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)
+        def attacher(record, **)
+          attacher = class_attacher(**)
           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)
+        def class_attacher(**)
+          attacher = shrine_class::Attacher.new(**@options, **)
           attacher.instance_variable_set(:@name, @name)
           attacher
         end
@@ -75,8 +81,8 @@ class Shrine
         #
         #     attacher = Attacher.from_entity(photo, :image)
         #     attacher.file #=> #<Shrine::UploadedFile>
-        def from_entity(record, name, **options)
-          attacher = new(**options)
+        def from_entity(record, name, **)
+          attacher = new(**)
           attacher.load_entity(record, name)
           attacher
         end

data/lib/shrine/plugins/fallback_storage.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # Documentation can be found on https://shrinerb.com/docs/plugins/fallback_storage
+    module FallbackStorage
+      def self.configure(uploader, **opts)
+        uploader.opts[:fallback_storage] ||= { store: :fallback }
+        uploader.opts[:fallback_storage].merge!(opts)
+
+        uploader.find_storage(uploader.opts.dig(:fallback_storage, :store))
+      end
+
+      module FileMethods
+        def self.included(base)
+          base.class_eval do
+            alias_method :storage_exists?, :exists?
+
+            def exists?
+              super || fallback_storage.exists?(id)
+            end
+          end
+        end
+
+        def url(**)
+          if storage_exists?
+            super
+          else
+            fallback_storage.url(id, **)
+          end
+        end
+
+        private
+
+        def _open(**)
+          if storage_exists?
+            super
+          else
+            fallback_storage.open(id, **)
+          end
+        end
+
+        def fallback_storage
+          shrine_class.find_storage(shrine_class.opts.dig(:fallback_storage, :store))
+        end
+      end
+    end
+
+    register_plugin(:fallback_storage, FallbackStorage)
+  end
+end

data/lib/shrine/plugins/infer_extension.rb

@@ -46,11 +46,15 @@ class Shrine
         def instrument_extension(mime_type, &block)
           return yield unless respond_to?(:instrument)
 
-          instrument(:extension, mime_type: mime_type, &block)
+          instrument(:extension, mime_type:, &block)
         end
       end
 
       module InstanceMethods
+        def infer_extension(mime_type)
+          self.class.infer_extension(mime_type)
+        end
+
         private
 
         def basic_location(io, metadata:)

data/lib/shrine/plugins/instrumentation.rb

@@ -12,7 +12,11 @@ class Shrine
       def self.configure(uploader, log_subscriber: LOG_SUBSCRIBER, **opts)
         uploader.opts[:instrumentation] ||= { log_events: EVENTS, subscribers: {} }
         uploader.opts[:instrumentation].merge!(opts)
-        uploader.opts[:instrumentation][:notifications] ||= ::ActiveSupport::Notifications
+        begin
+          uploader.opts[:instrumentation][:notifications] ||= ::ActiveSupport::Notifications
+        rescue NameError
+          fail Error, "default notifications library is ActiveSupport::Notifications, but activesupport gem is not installed"
+        end
 
         uploader.opts[:instrumentation][:log_events].each do |event_name|
           uploader.subscribe(event_name, &log_subscriber)
@@ -165,14 +169,14 @@ class Shrine
           end
         end
 
-        def library_send(method_name, *args, &block)
+        def library_send(method_name, ...)
           case notifications.to_s
           when /Dry::Monitor::Notifications/
-            send(:"dry_monitor_#{method_name}", *args, &block)
+            send(:"dry_monitor_#{method_name}", ...)
           when /ActiveSupport::Notifications/
-            send(:"active_support_#{method_name}", *args, &block)
+            send(:"active_support_#{method_name}", ...)
           else
-            notifications.send(method_name, *args, &block)
+            notifications.send(method_name, ...)
           end
         end
       end
@@ -220,14 +224,14 @@ class Shrine
           event.duration.to_i
         end
 
-        def library_send(method_name, *args, &block)
+        def library_send(method_name, ...)
           case event.class.name
           when "ActiveSupport::Notifications::Event"
-            send(:"active_support_#{method_name}", *args, &block)
+            send(:"active_support_#{method_name}", ...)
           when "Dry::Events::Event"
-            send(:"dry_events_#{method_name}", *args, &block)
+            send(:"dry_events_#{method_name}", ...)
           else
-            event.send(method_name, *args, &block)
+            event.send(method_name, ...)
           end
         end
       end

data/lib/shrine/plugins/metadata_attributes.rb

@@ -4,7 +4,7 @@ class Shrine
   module Plugins
     # Documentation can be found on https://shrinerb.com/docs/plugins/metadata_attributes
     module MetadataAttributes
-      def self.load_dependencies(uploader, *)
+      def self.load_dependencies(uploader, **)
         uploader.plugin :entity
       end
 

data/lib/shrine/plugins/mirroring.rb

@@ -51,9 +51,9 @@ class Shrine
 
       module InstanceMethods
         # Mirrors upload to other mirror storages.
-        def upload(io, mirror: true, **options)
-          file = super(io, **options)
-          file.trigger_mirror_upload(**options) if mirror
+        def upload(io, mirror: true, **)
+          file = super(io, **)
+          file.trigger_mirror_upload(**) if mirror
           file
         end
       end
@@ -61,31 +61,31 @@ class Shrine
       module FileMethods
         # Mirrors upload if mirrors are defined. Calls mirror block if
         # registered, otherwise mirrors synchronously.
-        def trigger_mirror_upload(**options)
+        def trigger_mirror_upload(**)
           return unless shrine_class.mirrors[storage_key] && shrine_class.mirror_upload?
 
           if shrine_class.mirror_upload_block
-            mirror_upload_background(**options)
+            mirror_upload_background(**)
           else
-            mirror_upload(**options)
+            mirror_upload(**)
           end
         end
 
         # Calls mirror upload block.
-        def mirror_upload_background(**options)
+        def mirror_upload_background(**)
           fail Error, "mirror upload block is not registered" unless shrine_class.mirror_upload_block
 
-          shrine_class.mirror_upload_block.call(self, **options)
+          shrine_class.mirror_upload_block.call(self, **)
         end
 
         # Uploads the file to each mirror storage.
-        def mirror_upload(**options)
+        def mirror_upload(**)
           previously_opened = opened?
 
           each_mirror do |mirror|
             rewind if opened?
 
-            shrine_class.upload(self, mirror, **options, location: id, close: false, action: :mirror)
+            shrine_class.upload(self, mirror, **, location: id, close: false, action: :mirror)
           end
         ensure
           if opened? && !previously_opened

data/lib/shrine/plugins/model.rb

@@ -18,8 +18,8 @@ class Shrine
         #
         #     Shrine::Attachment(:image)               # model (default)
         #     Shrine::Attachment(:image, model: false) # entity
-        def initialize(name, model: true, **options)
-          super(name, **options)
+        def initialize(name, model: true, **)
+          super(name, **)
           @model = model
         end
 
@@ -48,7 +48,9 @@ class Shrine
           # The copy constructor that's called on #dup and #clone.
           define_method :initialize_copy do |other|
             super(other)
-            instance_variable_set(:"@#{name}_attacher", instance_variable_get(:"@#{name}_attacher")&.dup)
+            attacher_copy = instance_variable_get(:"@#{name}_attacher")&.dup
+            attacher_copy.set_entity(self, name) if attacher_copy
+            instance_variable_set(:"@#{name}_attacher", attacher_copy)
             self
           end
           private :initialize_copy
@@ -80,16 +82,16 @@ class Shrine
         #
         #     attacher = Attacher.from_model(photo, :image)
         #     attacher.file #=> #<Shrine::UploadedFile>
-        def from_model(record, name, **options)
-          attacher = new(**options)
+        def from_model(record, name, **)
+          attacher = new(**)
           attacher.load_model(record, name)
           attacher
         end
       end
 
       module AttacherMethods
-        def initialize(model_cache: shrine_class.opts[:model][:cache], **options)
-          super(**options)
+        def initialize(model_cache: shrine_class.opts[:model][:cache], **)
+          super(**)
           @model_cache = model_cache
           @model       = nil
         end
@@ -109,11 +111,11 @@ class Shrine
         end
 
         # Called by the attachment attribute setter on the model.
-        def model_assign(value, **options)
+        def model_assign(value, **)
           if model_cache?
-            assign(value, **options)
+            assign(value, **)
           else
-            attach(value, **options)
+            attach(value, **)
           end
         end
 

data/lib/shrine/plugins/presign_endpoint.rb

@@ -21,12 +21,12 @@ class Shrine
         # The `storage_key` needs to be one of the registered Shrine storages.
         # Additional options can be given to override the options given on
         # plugin initialization.
-        def presign_endpoint(storage_key, **options)
+        def presign_endpoint(storage_key, **)
           Shrine::PresignEndpoint.new(
             shrine_class: self,
             storage_key:  storage_key,
             **opts[:presign_endpoint],
-            **options,
+            **,
           )
         end
 
@@ -36,7 +36,7 @@ class Shrine
         # It performs the same mounting logic that Rack and other web
         # frameworks use, and is meant for cases where statically mounting the
         # endpoint in the router isn't enough.
-        def presign_response(storage_key, env, **options)
+        def presign_response(storage_key, env, **)
           script_name = env["SCRIPT_NAME"]
           path_info   = env["PATH_INFO"]
 
@@ -44,7 +44,7 @@ class Shrine
             env["SCRIPT_NAME"] += path_info
             env["PATH_INFO"]    = ""
 
-            presign_endpoint(storage_key, **options).call(env)
+            presign_endpoint(storage_key, **).call(env)
           ensure
             env["SCRIPT_NAME"] = script_name
             env["PATH_INFO"]   = path_info
@@ -91,7 +91,9 @@ class Shrine
         end
       end
 
-      headers["Content-Length"] ||= body.map(&:bytesize).inject(0, :+).to_s
+      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
 
       [status, headers, body]
     end
@@ -158,16 +160,17 @@ class Shrine
     # 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)
+      status, headers, body = if @rack_response
+        @rack_response.call(object, request)
       else
-        response = [200, { "Content-Type" => CONTENT_TYPE_JSON }, [object.to_json]]
+        [200, { "Content-Type" => CONTENT_TYPE_JSON }, [object.to_json]]
       end
 
+      headers = Rack::Headers[headers] if Rack.release >= "3"
       # prevent browsers from caching the response
-      response[1]["Cache-Control"] = "no-store" unless response[1].key?("Cache-Control")
+      headers["Cache-Control"] = "no-store" unless headers.key?("Cache-Control")
 
-      response
+      [status, headers, body]
     end
 
     # Used for early returning an error response.

data/lib/shrine/plugins/pretty_location.rb

@@ -10,8 +10,8 @@ class Shrine
       end
 
       module InstanceMethods
-        def generate_location(io, **options)
-          pretty_location(io, **options)
+        def generate_location(io, **)
+          pretty_location(io, **)
         end
 
         def pretty_location(io, name: nil, record: nil, version: nil, derivative: nil, identifier: nil, metadata: {}, **)

data/lib/shrine/plugins/processing.rb

@@ -18,14 +18,14 @@ class Shrine
       end
 
       module InstanceMethods
-        def upload(io, process: true, **options)
+        def upload(io, process: true, **)
           if process
-            input = process(io, **options)
+            input = process(io, **)
           else
             input = io
           end
 
-          super(input, **options)
+          super(input, **)
         end
 
         private

data/lib/shrine/plugins/rack_file.rb

@@ -24,9 +24,9 @@ class Shrine
       module AttacherMethods
         # Checks whether a file is a Rack file hash, and in that case wraps the
         # hash in an IO-like object.
-        def assign(value, **options)
+        def assign(value, **)
           if rack_file?(value)
-            assign shrine_class.rack_file(value), **options
+            assign shrine_class.rack_file(value), **
           else
             super
           end

data/lib/shrine/plugins/rack_response.rb

@@ -10,8 +10,8 @@ class Shrine
     module RackResponse
       module FileMethods
         # Returns a Rack response triple for the uploaded file.
-        def to_rack_response(**options)
-          FileResponse.new(self).call(**options)
+        def to_rack_response(**)
+          FileResponse.new(self).call(**)
         end
       end
 
@@ -32,6 +32,8 @@ class Shrine
           headers = rack_headers(**options)
           body    = rack_body(**options)
 
+          headers = Rack::Headers[headers] if Rack.release >= "3"
+
           [status, headers, body]
         end
 
@@ -47,14 +49,14 @@ class Shrine
         # "Content-Disposition" headers, whose values are extracted from
         # metadata. Also returns the correct "Content-Range" header on ranged
         # requests.
-        def rack_headers(filename: nil, type: nil, disposition: "inline", range: false)
+        def rack_headers(filename: nil, type: nil, disposition: "inline", range: false, etag: 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,
+            "ETag"                => etag || self.etag,
           }.compact
         end
 
@@ -73,7 +75,7 @@ class Shrine
         def content_disposition(disposition, filename)
           filename ||= file.original_filename || file.id.split("/").last
 
-          ContentDisposition.format(disposition: disposition, filename: filename)
+          ContentDisposition.format(disposition:, filename:)
         end
 
         # Value for the "Content-Range" header.
@@ -96,7 +98,7 @@ class Shrine
         # Returns an object that responds to #each and #close, which yields
         # contents of the file.
         def rack_body(range: nil, **)
-          FileBody.new(file, range: range)
+          FileBody.new(file, range:)
         end
 
         # Retrieves a range value parsed from HTTP "Range" header.
@@ -141,6 +143,10 @@ class Shrine
           file.close
         end
 
+        def bytesize
+          each.inject(0) { |sum, chunk| sum += chunk.length }
+        end
+
         # Rack::Sendfile is activated when response body responds to #to_path.
         def respond_to_missing?(name, include_private = false)
           name == :to_path && path

data/lib/shrine/plugins/refresh_metadata.rb

@@ -5,19 +5,19 @@ class Shrine
     # Documentation can be found on https://shrinerb.com/docs/plugins/refresh_metadata
     module RefreshMetadata
       module AttacherMethods
-        def refresh_metadata!(**options)
-          file!.refresh_metadata!(**context, **options)
+        def refresh_metadata!(**)
+          file!.refresh_metadata!(**context, **)
           set(file) # trigger model write
         end
       end
 
       module FileMethods
-        def refresh_metadata!(**options)
-          return open { refresh_metadata!(**options) } unless opened?
+        def refresh_metadata!(replace: false, **)
+          return open { refresh_metadata!(replace:, **) } unless opened?
 
-          refreshed_metadata = uploader.send(:get_metadata, self, metadata: true, **options)
+          refreshed_metadata = uploader.send(:get_metadata, self, metadata: true, **)
 
-          @metadata = @metadata.merge(refreshed_metadata)
+          @metadata = replace ? refreshed_metadata : @metadata.merge(refreshed_metadata)
         end
       end
     end

data/lib/shrine/plugins/remote_url.rb

@@ -18,7 +18,7 @@ class Shrine
 
       DOWNLOADER = -> (url, **options) { Down.download(url, **options) }
 
-      def self.load_dependencies(uploader, *)
+      def self.load_dependencies(uploader, **)
         uploader.plugin :validation
       end
 
@@ -84,11 +84,11 @@ 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: {}, **options)
+        def assign_remote_url(url, downloader: {}, **)
           return if url == "" || url.nil?
 
           downloaded_file = shrine_class.remote_url(url, **downloader)
-          attach_cached(downloaded_file, **options)
+          attach_cached(downloaded_file, **)
         rescue DownloadError => error
           errors.clear << remote_url_error_message(url, error)
           false
@@ -110,7 +110,7 @@ class Shrine
         # Generates an error message for failed remote URL download.
         def remote_url_error_message(url, error)
           message = shrine_class.opts[:remote_url][:error_message]
-          message = message.call *[url, error].take(message.arity.abs) if message.respond_to?(:call)
+          message = message.call(*[url, error].take(message.arity.abs)) if message.respond_to?(:call)
           message || "download failed: #{error.message}"
         end
       end

data/lib/shrine/plugins/remove_attachment.rb

@@ -39,6 +39,8 @@ class Shrine
 
         # Rails sends "0" or "false" if the checkbox hasn't been ticked.
         def remove?
+          return remove if [true, false].include?(remove)
+
           remove && remove != "" && remove !~ /\A(0|false)\z/
         end
       end

data/lib/shrine/plugins/remove_invalid.rb

@@ -26,6 +26,10 @@ class Shrine
           else
             load_data nil
           end
+
+          # `load_data` bypasses `Attacher#set`, so when the model plugin is
+          # loaded the record attribute needs to be synced manually.
+          write if respond_to?(:write)
         end
       end
     end

data/lib/shrine/plugins/restore_cached_data.rb

@@ -11,14 +11,14 @@ class Shrine
       module AttacherMethods
         private
 
-        def cached(value, **options)
+        def cached(value, **)
           cached_file = super
 
           # TODO: Remove this conditional when we remove the versions plugin
           if cached_file.is_a?(Hash) || cached_file.is_a?(Array)
-            uploaded_file(cached_file) { |file| file.refresh_metadata!(**context, **options) }
+            uploaded_file(cached_file) { |file| file.refresh_metadata!(**context, **) }
           else
-            cached_file.refresh_metadata!(**context, **options)
+            cached_file.refresh_metadata!(**context, **)
           end
 
           cached_file

data/lib/shrine/plugins/sequel.rb

@@ -87,8 +87,11 @@ class Shrine
           end
         end
 
-        # Calls Attacher#save. Called before model save.
+        # Calls Attacher#save. Called before model save. Remembers whether
+        # the record is new, since by the time `#sequel_after_save` runs,
+        # Sequel has already flipped `#new?` to false.
         def sequel_before_save
+          @previously_new_record = record.new?
           save
         end
 
@@ -132,6 +135,17 @@ class Shrine
         def sequel?
           record.is_a?(::Sequel::Model)
         end
+
+        # Prevents the previous file from being destroyed when this save
+        # created the record (as opposed to updating an existing one), since
+        # a record being created can't yet have its own confirmed attachment
+        # to safely replace (e.g. when it was duplicated from another,
+        # still-persisted record).
+        def destroy_previous?
+          return super unless sequel?
+
+          super && !@previously_new_record
+        end
       end
     end
 

data/lib/shrine/plugins/signature.rb

@@ -37,7 +37,7 @@ class Shrine
         def instrument_signature(io, algorithm, format, &block)
           return yield unless respond_to?(:instrument)
 
-          instrument(:signature, io: io, algorithm: algorithm, format: format, &block)
+          instrument(:signature, io:, algorithm:, format:, &block)
         end
       end
 
@@ -45,7 +45,7 @@ class Shrine
         # Calculates `algorithm` hash of the contents of the IO object, and
         # encodes it into `format`.
         def calculate_signature(io, algorithm, format: :hex)
-          self.class.calculate_signature(io, algorithm, format: format)
+          self.class.calculate_signature(io, algorithm, format:)
         end
       end
 

data/lib/shrine/plugins/store_dimensions.rb

@@ -57,7 +57,7 @@ class Shrine
         def dimensions_analyzer(name)
           on_error = opts[:store_dimensions][:on_error]
 
-          DimensionsAnalyzer.new(name, on_error: on_error).method(:call)
+          DimensionsAnalyzer.new(name, on_error:).method(:call)
         end
 
         private
@@ -66,7 +66,7 @@ class Shrine
         def instrument_dimensions(io, &block)
           return yield unless respond_to?(:instrument)
 
-          instrument(:image_dimensions, io: io, &block)
+          instrument(:image_dimensions, io:, &block)
         end
       end
 

data/lib/shrine/plugins/tempfile.rb

@@ -19,8 +19,6 @@ class Shrine
 
       module FileMethods
         def tempfile
-          raise Error, "uploaded file must be opened" unless @io
-
           @tempfile ||= download
           @tempfile.rewind
           @tempfile