shrine 3.1.0 → 3.4.0

data/lib/shrine/plugins/instrumentation.rb

@@ -69,27 +69,25 @@ class Shrine
 
         # Sends a `upload.shrine` event.
         def _upload(io, location:, metadata:, upload_options: {}, **options)
-          self.class.instrument(
-            :upload,
+          self.class.instrument(:upload, {
             storage: storage_key,
             location: location,
             io: io,
             upload_options: upload_options,
             metadata: metadata,
             options: options,
-          ) { super }
+          }) { super }
         end
 
         # Sends a `metadata.shrine` event.
         def get_metadata(io, metadata: nil, **options)
           return super if io.is_a?(UploadedFile) && metadata != true || metadata == false
 
-          self.class.instrument(
-            :metadata,
+          self.class.instrument(:metadata, {
             storage: storage_key,
             io: io,
             options: options,
-          ) { super }
+          }) { super }
         end
       end
 
@@ -98,30 +96,27 @@ class Shrine
         def stream(destination, **options)
           return super if opened?
 
-          shrine_class.instrument(
-            :download,
+          shrine_class.instrument(:download, {
             storage: storage_key,
             location: id,
             download_options: options,
-          ) { super(destination, **options, instrument: false) }
+          }) { super(destination, **options, instrument: false) }
         end
 
         # Sends a `exists.shrine` event.
         def exists?
-          shrine_class.instrument(
-            :exists,
+          shrine_class.instrument(:exists, {
             storage: storage_key,
             location: id,
-          ) { super }
+          }) { super }
         end
 
         # Sends a `delete.shrine` event.
         def delete
-          shrine_class.instrument(
-            :delete,
+          shrine_class.instrument(:delete, {
             storage: storage_key,
             location: id,
-          ) { super }
+          }) { super }
         end
 
         private
@@ -130,12 +125,11 @@ class Shrine
         def _open(instrument: true, **options)
           return super(**options) unless instrument
 
-          shrine_class.instrument(
-            :open,
+          shrine_class.instrument(:open, {
             storage: storage_key,
             location: id,
             download_options: options,
-          ) { super(**options) }
+          }) { super(**options) }
         end
       end
 

data/lib/shrine/plugins/mirroring.rb

@@ -53,7 +53,7 @@ class Shrine
         # Mirrors upload to other mirror storages.
         def upload(io, mirror: true, **options)
           file = super(io, **options)
-          file.trigger_mirror_upload if mirror
+          file.trigger_mirror_upload(**options) 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
+        def trigger_mirror_upload(**options)
           return unless shrine_class.mirrors[storage_key] && shrine_class.mirror_upload?
 
           if shrine_class.mirror_upload_block
-            mirror_upload_background
+            mirror_upload_background(**options)
           else
-            mirror_upload
+            mirror_upload(**options)
           end
         end
 
         # Calls mirror upload block.
-        def mirror_upload_background
+        def mirror_upload_background(**options)
           fail Error, "mirror upload block is not registered" unless shrine_class.mirror_upload_block
 
-          shrine_class.mirror_upload_block.call(self)
+          shrine_class.mirror_upload_block.call(self, **options)
         end
 
         # Uploads the file to each mirror storage.
-        def mirror_upload
+        def mirror_upload(**options)
           previously_opened = opened?
 
           each_mirror do |mirror|
             rewind if opened?
 
-            shrine_class.upload(self, mirror, location: id, close: false, action: :mirror)
+            shrine_class.upload(self, mirror, **options, location: id, close: false, action: :mirror)
           end
         ensure
           if opened? && !previously_opened

data/lib/shrine/plugins/model.rb

@@ -55,11 +55,11 @@ class Shrine
         end
 
         # Memoizes the attacher instance into an instance variable.
-        def attacher(record, options)
+        def attacher(record, **options)
           return super unless model?
 
           if !record.instance_variable_get(:"@#{@name}_attacher") || options.any?
-            attacher = class_attacher(options)
+            attacher = class_attacher(**options)
             attacher.load_model(record, @name)
 
             record.instance_variable_set(:"@#{@name}_attacher", attacher)
@@ -118,7 +118,7 @@ class Shrine
         end
 
         # Writes uploaded file data into the model.
-        def set(*args)
+        def set(*)
           result = super
           write if model?
           result

data/lib/shrine/plugins/presign_endpoint.rb

@@ -8,7 +8,7 @@ class Shrine
   module Plugins
     # Documentation can be found on https://shrinerb.com/docs/plugins/presign_endpoint
     module PresignEndpoint
-      def self.configure(uploader, opts = {})
+      def self.configure(uploader, **opts)
         uploader.opts[:presign_endpoint] ||= {}
         uploader.opts[:presign_endpoint].merge!(opts)
       end
@@ -81,9 +81,14 @@ class Shrine
 
       status, headers, body = catch(:halt) do
         error!(404, "Not Found") unless ["", "/"].include?(request.path_info)
-        error!(405, "Method Not Allowed") unless request.get?
 
-        handle_request(request)
+        if request.get?
+          handle_request(request)
+        elsif request.options?
+          handle_options_request(request)
+        else
+          error!(405, "Method Not Allowed")
+        end
       end
 
       headers["Content-Length"] ||= body.map(&:bytesize).inject(0, :+).to_s
@@ -109,6 +114,13 @@ class Shrine
       make_response(presign, request)
     end
 
+    # Uppy client sends an OPTIONS request to fetch information about the
+    # Uppy Companion. Since our Rack app is only acting as Uppy Companion, we
+    # just return a successful response.
+    def handle_options_request(request)
+      [200, {}, []]
+    end
+
     # Generates the location using `Shrine#generate_uid`, and extracts the
     # extension from the `filename` query parameter. If `:presign_location`
     # option is given, calls that instead.
@@ -135,7 +147,7 @@ class Shrine
       if @presign
         data = @presign.call(location, options, request)
       else
-        data = storage.presign(location, options)
+        data = storage.presign(location, **options)
       end
 
       { fields: {}, headers: {} }.merge(data.to_h)

data/lib/shrine/plugins/pretty_location.rb

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

data/lib/shrine/plugins/processing.rb

@@ -33,7 +33,7 @@ class Shrine
         def process(io, **options)
           pipeline = processing_pipeline(options[:action])
           pipeline.inject(io) do |input, processor|
-            instance_exec(input, options, &processor) || input
+            instance_exec(input, **options, &processor) || input
           end
         end
 

data/lib/shrine/plugins/refresh_metadata.rb

@@ -6,8 +6,8 @@ class Shrine
     module RefreshMetadata
       module AttacherMethods
         def refresh_metadata!(**options)
-          file.refresh_metadata!(**context, **options)
-          set(file)
+          file!.refresh_metadata!(**context, **options)
+          set(file) # trigger model write
         end
       end
 

data/lib/shrine/plugins/remote_url.rb

@@ -16,7 +16,7 @@ class Shrine
         }.inspect}"
       end
 
-      DOWNLOADER = -> (url, options) { Down.download(url, options) }
+      DOWNLOADER = -> (url, **options) { Down.download(url, **options) }
 
       def self.load_dependencies(uploader, *)
         uploader.plugin :validation
@@ -63,7 +63,7 @@ class Shrine
         private
 
         def download_remote_url(url, options)
-          opts[:remote_url][:downloader].call(url, options)
+          opts[:remote_url][:downloader].call(url, **options)
         rescue Down::TooLarge
           fail DownloadError, "remote file too large"
         rescue Down::Error
@@ -87,7 +87,7 @@ class Shrine
         def assign_remote_url(url, downloader: {}, **options)
           return if url == "" || url.nil?
 
-          downloaded_file = shrine_class.remote_url(url, downloader)
+          downloaded_file = shrine_class.remote_url(url, **downloader)
           attach_cached(downloaded_file, **options)
         rescue DownloadError => error
           errors.clear << remote_url_error_message(url, error)

data/lib/shrine/plugins/remove_attachment.rb

@@ -32,6 +32,11 @@ class Shrine
 
         private
 
+        # Don't override previously removed attachment that wasn't yet deleted.
+        def change?(file)
+          super && !(changed? && remove?)
+        end
+
         # Rails sends "0" or "false" if the checkbox hasn't been ticked.
         def remove?
           remove && remove != "" && remove !~ /\A(0|false)\z/

data/lib/shrine/plugins/remove_invalid.rb

@@ -9,18 +9,23 @@ class Shrine
       end
 
       module AttacherMethods
-        def change(*)
+        def validate(*)
           super
         ensure
-          revert_change if errors.any?
+          deassign if errors.any?
         end
 
         private
 
-        def revert_change
+        def deassign
           destroy
-          set @previous.file
-          remove_instance_variable(:@previous)
+
+          if changed?
+            load_data @previous.data
+            @previous = nil
+          else
+            load_data nil
+          end
         end
       end
     end

data/lib/shrine/plugins/sequel.rb

@@ -62,7 +62,7 @@ class Shrine
           # reload the attacher on record reload
           define_method :_refresh do |*args|
             result = super(*args)
-            instance_variable_set(:"@#{name}_attacher", nil)
+            send(:"#{name}_attacher").reload if instance_variable_defined?(:"@#{name}_attacher")
             result
           end
           private :_refresh

data/lib/shrine/plugins/store_dimensions.rb

@@ -12,7 +12,7 @@ class Shrine
       end
 
       def self.configure(uploader, log_subscriber: LOG_SUBSCRIBER, **opts)
-        uploader.opts[:store_dimensions] ||= { analyzer: :fastimage, on_error: :warn }
+        uploader.opts[:store_dimensions] ||= { analyzer: :fastimage, on_error: :warn, auto_extraction: true }
         uploader.opts[:store_dimensions].merge!(opts)
 
         # resolve error strategy
@@ -71,8 +71,10 @@ class Shrine
       end
 
       module InstanceMethods
-        # We update the metadata with "width" and "height".
         def extract_metadata(io, **options)
+          return super unless opts[:store_dimensions][:auto_extraction]
+
+          # We update the metadata with "width" and "height".
           width, height = self.class.extract_dimensions(io)
 
           super.merge!("width" => width, "height" => height)

data/lib/shrine/plugins/type_predicates.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # Documentation can be found on https://shrinerb.com/docs/plugins/type_predicates
+    module TypePredicates
+      def self.configure(uploader, methods: [], **opts)
+        uploader.opts[:type_predicates] ||= { mime: :mini_mime }
+        uploader.opts[:type_predicates].merge!(opts)
+
+        methods.each do |name|
+          uploader::UploadedFile.send(:define_method, "#{name}?") { type?(name) }
+        end
+      end
+
+      module ClassMethods
+        def type_lookup(extension, database = nil)
+          database ||= opts[:type_predicates][:mime]
+          database   = MimeDatabase.new(database) if database.is_a?(Symbol)
+          database.call(extension.to_s)
+        end
+      end
+
+      module FileMethods
+        def image?
+          general_type?("image")
+        end
+
+        def video?
+          general_type?("video")
+        end
+
+        def audio?
+          general_type?("audio")
+        end
+
+        def text?
+          general_type?("text")
+        end
+
+        def type?(type)
+          matching_mime_type = shrine_class.type_lookup(type)
+
+          fail Error, "type #{type.inspect} is not recognized by the MIME library" unless matching_mime_type
+
+          mime_type! == matching_mime_type
+        end
+
+        private
+
+        def general_type?(type)
+          mime_type!.start_with?(type)
+        end
+
+        def mime_type!
+          mime_type or fail Error, "mime_type metadata value is missing"
+        end
+      end
+
+      class MimeDatabase
+        SUPPORTED_TOOLS = %i[mini_mime mime_types mimemagic marcel rack_mime]
+
+        def initialize(tool)
+          raise Error, "unknown type database #{tool.inspect}, supported databases are: #{SUPPORTED_TOOLS.join(",")}" unless SUPPORTED_TOOLS.include?(tool)
+
+          @tool = tool
+        end
+
+        def call(extension)
+          send(:"lookup_with_#{@tool}", extension)
+        end
+
+        private
+
+        def lookup_with_mini_mime(extension)
+          require "mini_mime"
+
+          info = MiniMime.lookup_by_extension(extension)
+          info&.content_type
+        end
+
+        def lookup_with_mime_types(extension)
+          require "mime/types"
+
+          mime_type = MIME::Types.of(".#{extension}").first
+          mime_type&.content_type
+        end
+
+        def lookup_with_mimemagic(extension)
+          require "mimemagic"
+
+          magic = MimeMagic.by_extension(".#{extension}")
+          magic&.type
+        end
+
+        def lookup_with_marcel(extension)
+          require "marcel"
+
+          type = Marcel::MimeType.for(extension: ".#{extension}")
+          type unless type == "application/octet-stream"
+        end
+
+        def lookup_with_rack_mime(extension)
+          require "rack/mime"
+
+          Rack::Mime.mime_type(".#{extension}", nil)
+        end
+      end
+    end
+
+    register_plugin(:type_predicates, TypePredicates)
+  end
+end