shrine 2.19.3 → 3.6.0

data/lib/shrine/plugins/model.rb

@@ -0,0 +1,160 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # Documentation can be found on https://shrinerb.com/docs/plugins/model
+    module Model
+      def self.load_dependencies(uploader, **)
+        uploader.plugin :entity
+      end
+
+      def self.configure(uploader, **opts)
+        uploader.opts[:model] ||= { cache: true }
+        uploader.opts[:model].merge!(opts)
+      end
+
+      module AttachmentMethods
+        # Allows disabling model behaviour:
+        #
+        #     Shrine::Attachment(:image)               # model (default)
+        #     Shrine::Attachment(:image, model: false) # entity
+        def initialize(name, model: true, **options)
+          super(name, **options)
+          @model = model
+        end
+
+        # We define model methods only on inclusion. This gives other plugins
+        # the ability to disable model behaviour for entity classes. In this
+        # case we want to skip defining model methods as well.
+        def included(klass)
+          super
+          define_model_methods(@name) if model?
+        end
+
+        private
+
+        # Defines attachment setter and enhances the copy constructor.
+        def define_model_methods(name)
+          super if defined?(super)
+
+          define_method :"#{name}=" do |value|
+            send(:"#{name}_attacher").model_assign(value)
+          end
+
+          define_method :"#{name}_changed?" do
+            send(:"#{name}_attacher").changed?
+          end
+
+          # The copy constructor that's called on #dup and #clone.
+          define_method :initialize_copy do |other|
+            super(other)
+            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
+        end
+
+        # Memoizes the attacher instance into an instance variable.
+        def attacher(record, **options)
+          return super unless model?
+
+          if !record.instance_variable_get(:"@#{@name}_attacher") || options.any?
+            attacher = class_attacher(**options)
+            attacher.load_model(record, @name)
+
+            record.instance_variable_set(:"@#{@name}_attacher", attacher)
+          else
+            record.instance_variable_get(:"@#{@name}_attacher")
+          end
+        end
+
+        def model?
+          @model
+        end
+      end
+
+      module AttacherClassMethods
+        # Initializes itself from a model instance and attachment name.
+        #
+        #     photo.image_data #=> "{...}" # a file is attached
+        #
+        #     attacher = Attacher.from_model(photo, :image)
+        #     attacher.file #=> #<Shrine::UploadedFile>
+        def from_model(record, name, **options)
+          attacher = new(**options)
+          attacher.load_model(record, name)
+          attacher
+        end
+      end
+
+      module AttacherMethods
+        def initialize(model_cache: shrine_class.opts[:model][:cache], **options)
+          super(**options)
+          @model_cache = model_cache
+          @model       = nil
+        end
+
+        # Saves record and name and initializes attachment from the model
+        # attribute. Called from `Attacher.from_model`.
+        def load_model(record, name)
+          set_model(record, name)
+          read
+        end
+
+        # Saves record and name without loading attachment from the model
+        # attribute.
+        def set_model(record, name)
+          set_entity(record, name)
+          @model = true
+        end
+
+        # Called by the attachment attribute setter on the model.
+        def model_assign(value, **options)
+          if model_cache?
+            assign(value, **options)
+          else
+            attach(value, **options)
+          end
+        end
+
+        # Writes uploaded file data into the model.
+        def set(*)
+          result = super
+          write if model?
+          result
+        end
+
+        # Writes the attachment data into the model attribute.
+        def write
+          column_values.each do |name, value|
+            write_attribute(name, value)
+          end
+        end
+
+        private
+
+        # Writes given value into the model attribute.
+        def write_attribute(name = attribute, value)
+          record.public_send(:"#{name}=", value)
+        end
+
+        # Returns whether assigned files should be uploaded to/loaded from
+        # temporary storage.
+        def model_cache?
+          @model_cache
+        end
+
+        # Returns whether the attacher is being backed by a model instance.
+        # This allows users to still use the attacher with an entity instance
+        # or without any record instance.
+        def model?
+          @model
+        end
+      end
+    end
+
+    register_plugin(:model, Model)
+  end
+end

data/lib/shrine/plugins/module_include.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
+Shrine.deprecation("The module_include plugin is deprecated and will be removed in Shrine 4. Override core classes directly instead.")
+
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/module_include.md] on GitHub.
-    #
-    # [doc/plugins/module_include.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/module_include.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/module_include
     module ModuleInclude
       module ClassMethods
         def attachment_module(mod = nil, &block)

data/lib/shrine/plugins/multi_cache.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # Documentation can be found on https://shrinerb.com/docs/plugins/multi_cache
+    module MultiCache
+      def self.configure(uploader, **opts)
+        uploader.opts[:multi_cache] ||= {}
+        uploader.opts[:multi_cache].merge!(opts)
+      end
+
+      module AttacherMethods
+        def cached?(file = self.file)
+          super || additional_cache.any? { |key| uploaded?(file, key) }
+        end
+
+        private
+
+        def additional_cache
+          Array(shrine_class.opts[:multi_cache][:additional_cache])
+        end
+      end
+    end
+
+    register_plugin(:multi_cache, MultiCache)
+  end
+end

data/lib/shrine/plugins/presign_endpoint.rb

@@ -6,11 +6,9 @@ require "json"
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/presign_endpoint.md] on GitHub.
-    #
-    # [doc/plugins/presign_endpoint.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/presign_endpoint.md
+    # 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
@@ -83,12 +81,19 @@ 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
+      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
@@ -111,6 +116,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.
@@ -137,20 +149,10 @@ class Shrine
       if @presign
         data = @presign.call(location, options, request)
       else
-        data = storage.presign(location, options)
+        data = storage.presign(location, **options)
       end
 
-      if data.respond_to?(:to_h)
-        { fields: {}, headers: {} }.merge(data.to_h)
-      else
-        Shrine.deprecation("Returning a custom object in Storage#presign is deprecated, presign_endpoint will not support it in Shrine 3. Storage#presign should return a Hash instead.")
-
-        url     = data.url
-        fields  = data.fields
-        headers = data.headers if data.respond_to?(:headers)
-
-        { url: url, fields: fields.to_h, headers: headers.to_h }
-      end
+      { fields: {}, headers: {} }.merge(data.to_h)
     end
 
     # Transforms the presign hash into a JSON response. It returns a Rack
@@ -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.
@@ -185,8 +188,4 @@ class Shrine
       @shrine_class.find_storage(@storage_key)
     end
   end
-
-  # backwards compatibility
-  Plugins::PresignEndpoint.const_set(:App, PresignEndpoint)
-  Plugins::PresignEndpoint.deprecate_constant(:App)
 end

data/lib/shrine/plugins/pretty_location.rb

@@ -2,28 +2,26 @@
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/pretty_location.md] on GitHub.
-    #
-    # [doc/plugins/pretty_location.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/pretty_location.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/pretty_location
     module PrettyLocation
-      def self.configure(uploader, opts = {})
+      def self.configure(uploader, **opts)
         uploader.opts[:pretty_location] ||= { identifier: :id }
         uploader.opts[:pretty_location].merge!(opts)
       end
 
       module InstanceMethods
-        def generate_location(io, context)
-          pretty_location(io, context)
+        def generate_location(io, **options)
+          pretty_location(io, **options)
         end
 
-        def pretty_location(io, name: nil, record: nil, version: nil, identifier: nil, metadata: {}, **)
+        def pretty_location(io, name: nil, record: nil, version: nil, derivative: nil, identifier: nil, metadata: {}, **)
           if record
             namespace    = record_namespace(record)
             identifier ||= record_identifier(record)
           end
 
           basename = basic_location(io, metadata: metadata)
-          basename = "#{version}-#{basename}" if version
+          basename = [*(version || derivative), basename].join("-")
 
           [*namespace, *identifier, *name, basename].join("/")
         end
@@ -34,9 +32,17 @@ class Shrine
           record.public_send(opts[:pretty_location][:identifier])
         end
 
+        def transform_class_name(class_name)
+          if opts[:pretty_location][:class_underscore]
+            class_name.gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2').gsub(/([a-z])([A-Z])/, '\1_\2').downcase
+          else
+            class_name.downcase
+          end
+        end
+
         def record_namespace(record)
           class_name = record.class.name or return
-          parts      = class_name.downcase.split("::")
+          parts      = transform_class_name(class_name).split("::")
 
           if separator = opts[:pretty_location][:namespace]
             parts.join(separator)

data/lib/shrine/plugins/processing.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
+Shrine.deprecation("The processing 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/processing.md] on GitHub.
-    #
-    # [doc/plugins/processing.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/processing.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/processing
     module Processing
       def self.configure(uploader)
         uploader.opts[:processing] ||= {}
@@ -13,19 +13,32 @@ class Shrine
       module ClassMethods
         def process(action, &block)
           opts[:processing][action] ||= []
-          opts[:processing][action] += [block]
+          opts[:processing][action] << block
         end
       end
 
       module InstanceMethods
-        def process(io, context = {})
-          pipeline = opts[:processing][context[:action]] || []
+        def upload(io, process: true, **options)
+          if process
+            input = process(io, **options)
+          else
+            input = io
+          end
+
+          super(input, **options)
+        end
+
+        private
 
-          result = pipeline.inject(io) do |input, processing|
-            instance_exec(input, context, &processing) || input
+        def process(io, **options)
+          pipeline = processing_pipeline(options[:action])
+          pipeline.inject(io) do |input, processor|
+            instance_exec(input, **options, &processor) || input
           end
+        end
 
-          result unless result == io
+        def processing_pipeline(key)
+          opts[:processing][key] || []
         end
       end
     end

data/lib/shrine/plugins/rack_file.rb

@@ -4,9 +4,7 @@ require "forwardable"
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/rack_file.md] on GitHub.
-    #
-    # [doc/plugins/rack_file.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/rack_file.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/rack_file
     module RackFile
       module ClassMethods
         # Accepts a Rack uploaded file hash and wraps it in an IO object.
@@ -23,46 +21,12 @@ class Shrine
         end
       end
 
-      module InstanceMethods
-        # If `io` is a Rack uploaded file hash, converts it to an IO-like
-        # object and calls `super`.
-        def upload(io, context = {})
-          super(convert_rack_file(io), context)
-        end
-
-        # If `io` is a Rack uploaded file hash, converts it to an IO-like
-        # object and calls `super`.
-        def store(io, context = {})
-          super(convert_rack_file(io), context)
-        end
-
-        private
-
-        # If given a Rack uploaded file hash, returns a
-        # `Shrine::Plugins::RackFile::UploadedFile` IO-like object wrapping that
-        # hash, otherwise returns the value unchanged.
-        def convert_rack_file(value)
-          if rack_file?(value)
-            Shrine.deprecation("Passing a Rack uploaded file hash to Shrine#upload is deprecated, use Shrine.rack_file to convert the Rack file hash into an IO object.")
-            self.class.rack_file(value)
-          else
-            value
-          end
-        end
-
-        # Returns whether a given value is a Rack uploaded file hash, by
-        # checking whether it's a hash with `:tempfile` and `:name` keys.
-        def rack_file?(value)
-          value.is_a?(Hash) && value.key?(:tempfile) && value.key?(:name)
-        end
-      end
-
       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)
           if rack_file?(value)
-            assign(shrine_class.rack_file(value), **options)
+            assign shrine_class.rack_file(value), **options
           else
             super
           end
@@ -101,8 +65,4 @@ class Shrine
     extend Forwardable
     delegate [:read, :size, :rewind, :eof?, :close] => :@tempfile
   end
-
-  # backwards compatibility
-  Plugins::RackFile.const_set(:UploadedFile, RackFile)
-  Plugins::RackFile.deprecate_constant(:UploadedFile)
 end

data/lib/shrine/plugins/rack_response.rb

@@ -6,9 +6,7 @@ require "digest"
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/rack_response.md] on GitHub.
-    #
-    # [doc/plugins/rack_response.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/rack_response.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/rack_response
     module RackResponse
       module FileMethods
         # Returns a Rack response triple for the uploaded file.
@@ -34,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
 
@@ -101,16 +101,23 @@ class Shrine
           FileBody.new(file, range: range)
         end
 
-        # Parses the value of a "Range" HTTP header.
+        # Retrieves a range value parsed from HTTP "Range" header.
         def parse_content_range(range_header)
-          if Rack.release >= "2.0"
-            ranges = Rack::Utils.get_byte_ranges(range_header, file.size)
-          else
-            ranges = Rack::Utils.byte_ranges({ "HTTP_RANGE" => range_header }, file.size)
-          end
-
+          ranges = get_byte_ranges(range_header)
           ranges.first if ranges && ranges.one?
         end
+
+        if Rack.release >= "2.0"
+          def get_byte_ranges(range_header)
+            Rack::Utils.get_byte_ranges(range_header, file.size)
+          end
+        else
+          # :nocov:
+          def get_byte_ranges(range_header)
+            Rack::Utils.byte_ranges({ "HTTP_RANGE" => range_header }, file.size)
+          end
+          # :nocov:
+        end
       end
 
       # Implements the interface of a Rack response body object.
@@ -136,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/recache.rb

@@ -1,10 +1,10 @@
 # frozen_string_literal: true
 
+Shrine.deprecation("The recache 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/recache.md] on GitHub.
-    #
-    # [doc/plugins/recache.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/recache.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/recache
     module Recache
       module AttacherMethods
         def save
@@ -14,8 +14,9 @@ class Shrine
 
         def recache
           if cached?
-            recached = cache!(get, action: :recache)
-            _set(recached)
+            result = upload(file, cache_key, action: :recache)
+
+            set(result)
           end
         end
       end

data/lib/shrine/plugins/refresh_metadata.rb

@@ -2,20 +2,22 @@
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/refresh_metadata.md] on GitHub.
-    #
-    # [doc/plugins/refresh_metadata.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/refresh_metadata.md
+    # 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)
+          set(file) # trigger model write
+        end
+      end
+
       module FileMethods
-        def refresh_metadata!(**context)
-          refreshed_metadata =
-            if opened?
-              uploader.send(:get_metadata, self, metadata: true, **context)
-            else
-              open { uploader.send(:get_metadata, self, metadata: true, **context) }
-            end
+        def refresh_metadata!(**options)
+          return open { refresh_metadata!(**options) } unless opened?
+
+          refreshed_metadata = uploader.send(:get_metadata, self, metadata: true, **options)
 
-          @data = @data.merge("metadata" => metadata.merge(refreshed_metadata))
+          @metadata = @metadata.merge(refreshed_metadata)
         end
       end
     end