shrine 2.19.3 → 3.6.0

data/lib/shrine/plugins/cached_attachment_data.rb

@@ -2,30 +2,21 @@
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/cached_attachment_data.md] on GitHub.
-    #
-    # [doc/plugins/cached_attachment_data.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/cached_attachment_data.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/cached_attachment_data
     module CachedAttachmentData
       module AttachmentMethods
-        def initialize(*)
-          super
-
-          name = attachment_name
+        def define_model_methods(name)
+          super if defined?(super)
 
           define_method :"cached_#{name}_data" do
-            send(:"#{name}_attacher").read_cached
-          end
-
-          define_method :"cached_#{name}_data=" do |value|
-            Shrine.deprecation("Calling #cached_#{name}_data= is deprecated and will be removed in Shrine 3. You should use the original field name: `f.hidden_field :#{name}, value: record.cached_#{name}_data`.")
-            send(:"#{name}_attacher").assign(value)
+            send(:"#{name}_attacher").cached_data
           end
         end
       end
 
       module AttacherMethods
-        def read_cached
-          get.to_json if cached? && changed?
+        def cached_data
+          file.to_json if cached? && changed?
         end
       end
     end

data/lib/shrine/plugins/column.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+require "json"
+
+class Shrine
+  module Plugins
+    # Documentation can be found on https://shrinerb.com/docs/plugins/column
+    module Column
+      def self.configure(uploader, **opts)
+        uploader.opts[:column] ||= { serializer: JsonSerializer }
+        uploader.opts[:column].merge!(opts)
+      end
+
+      module AttacherClassMethods
+        # Initializes the attacher from a data hash/string expected to come
+        # from a database record column.
+        #
+        #     Attacher.from_column('{"id":"...","storage":"...","metadata":{...}}')
+        def from_column(data, **options)
+          attacher = new(**options)
+          attacher.load_column(data)
+          attacher
+        end
+      end
+
+      module AttacherMethods
+        # Column serializer object.
+        attr_reader :column_serializer
+
+        # Allows overriding the default column serializer.
+        def initialize(column_serializer: shrine_class.opts[:column][:serializer], **options)
+          super(**options)
+          @column_serializer = column_serializer
+        end
+
+        # Loads attachment from column data.
+        #
+        #     attacher.file #=> nil
+        #     attacher.load_column('{"id":"...","storage":"...","metadata":{...}}')
+        #     attacher.file #=> #<Shrine::UploadedFile>
+        def load_column(data)
+          load_data(deserialize_column(data))
+        end
+
+        # Returns attacher data as a serialized string (JSON by default).
+        #
+        #     attacher.column_data #=> '{"id":"...","storage":"...","metadata":{...}}'
+        def column_data
+          serialize_column(data)
+        end
+
+        private
+
+        # Converts the column data hash into a string (generates JSON by
+        # default).
+        #
+        #     Attacher.serialize_column({ "id" => "...", "storage" => "...", "metadata" => { ... } })
+        #     #=> '{"id":"...","storage":"...","metadata":{...}}'
+        #
+        #     Attacher.serialize_column(nil)
+        #     #=> nil
+        def serialize_column(data)
+          if column_serializer && data
+            column_serializer.dump(data)
+          else
+            data
+          end
+        end
+
+        # Converts the column data string into a hash (parses JSON by default).
+        #
+        #     Attacher.deserialize_column('{"id":"...","storage":"...","metadata":{...}}')
+        #     #=> { "id" => "...", "storage" => "...", "metadata" => { ... } }
+        #
+        #     Attacher.deserialize_column(nil)
+        #     #=> nil
+        def deserialize_column(data)
+          if column_serializer && data && !data.is_a?(Hash)
+            column_serializer.load(data)
+          else
+            data&.to_hash
+          end
+        end
+      end
+
+      # JSON.dump and JSON.load shouldn't be used with untrusted input, so we
+      # create this wrapper class which calls JSON.generate and JSON.parse
+      # instead.
+      class JsonSerializer
+        def self.dump(data)
+          JSON.generate(data)
+        end
+
+        def self.load(data)
+          JSON.parse(data)
+        end
+      end
+    end
+
+    register_plugin(:column, Column)
+  end
+end

data/lib/shrine/plugins/data_uri.rb

@@ -8,9 +8,7 @@ require "forwardable"
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/data_uri.md] on GitHub.
-    #
-    # [doc/plugins/data_uri.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/data_uri.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/data_uri
     module DataUri
       class ParseError < Error; end
 
@@ -26,17 +24,29 @@ class Shrine
         }.inspect}"
       end
 
-      def self.configure(uploader, opts = {})
-        uploader.opts[:data_uri] ||= { log_subscriber: LOG_SUBSCRIBER }
-        uploader.opts[:data_uri].merge!(opts)
+      def self.load_dependencies(uploader, *)
+        uploader.plugin :validation
+      end
 
-        if uploader.opts[:data_uri][:filename]
-          Shrine.deprecation("The :filename option is deprecated for the data_uri plugin, and will be removed in Shrine 3. Use the infer_extension plugin instead.")
-        end
+      def self.configure(uploader, log_subscriber: LOG_SUBSCRIBER, **opts)
+        uploader.opts[:data_uri] ||= {}
+        uploader.opts[:data_uri].merge!(opts)
 
         # instrumentation plugin integration
-        if uploader.respond_to?(:subscribe)
-          uploader.subscribe(:data_uri, &uploader.opts[:data_uri][:log_subscriber])
+        uploader.subscribe(:data_uri, &log_subscriber) if uploader.respond_to?(:subscribe)
+      end
+
+      module AttachmentMethods
+        def define_model_methods(name)
+          super if defined?(super)
+
+          define_method :"#{name}_data_uri=" do |uri|
+            send(:"#{name}_attacher").data_uri = uri
+          end
+
+          define_method :"#{name}_data_uri" do
+            send(:"#{name}_attacher").data_uri
+          end
         end
       end
 
@@ -57,10 +67,10 @@ class Shrine
 
         private
 
+        # Creates an IO-like object from parsed data URI.
         def create_data_file(info, filename: nil)
           content_type = info[:content_type] || DEFAULT_CONTENT_TYPE
           content      = info[:base64] ? Base64.decode64(info[:data]) : CGI.unescape(info[:data])
-          filename     = opts[:data_uri][:filename].call(content_type) if opts[:data_uri][:filename]
 
           data_file = Shrine::DataFile.new(content, content_type: content_type, filename: filename)
           info[:data].clear
@@ -68,6 +78,7 @@ class Shrine
           data_file
         end
 
+        # Parses the data URI string and returns parts.
         def parse_data_uri(uri)
           scanner = StringScanner.new(uri)
           scanner.scan(DATA_REGEXP) or raise ParseError, "data URI has invalid format"
@@ -87,20 +98,6 @@ class Shrine
         end
       end
 
-      module AttachmentMethods
-        def initialize(name, **options)
-          super
-
-          define_method :"#{name}_data_uri=" do |uri|
-            send(:"#{name}_attacher").data_uri = uri
-          end
-
-          define_method :"#{name}_data_uri" do
-            send(:"#{name}_attacher").data_uri
-          end
-        end
-      end
-
       module AttacherMethods
         # Handles assignment of a data URI. If the regexp matches, it extracts
         # the content type, decodes it, wrappes it in a StringIO and assigns it.
@@ -110,23 +107,31 @@ class Shrine
           return if uri == "" || uri.nil?
 
           data_file = shrine_class.data_uri(uri)
-          assign(data_file, **options)
+          attach_cached(data_file, **options)
         rescue ParseError => error
-          message = shrine_class.opts[:data_uri][:error_message] || error.message
-          message = message.call(uri) if message.respond_to?(:call)
-          errors.replace [message]
-          @data_uri = uri
+          errors.clear << data_uri_error_messsage(uri, error)
+          false
         end
 
-        # Alias for #assign_data_uri.
+        # Used by `<name>_data_uri=` attachment method.
         def data_uri=(uri)
           assign_data_uri(uri)
+          @data_uri = uri
         end
 
-        # Form builders require the reader as well.
+        # Used by `<name>_data_uri` attachment method.
         def data_uri
           @data_uri
         end
+
+        private
+
+        # Generates an error message for failed data URI parse.
+        def data_uri_error_messsage(uri, error)
+          message = shrine_class.opts[:data_uri][:error_message]
+          message = message.call(uri) if message.respond_to?(:call)
+          message || error.message
+        end
       end
 
       module FileMethods
@@ -169,7 +174,4 @@ class Shrine
       @io.string.clear # deallocate string
     end
   end
-
-  Plugins::DataUri.const_set(:DataFile, DataFile)
-  Plugins::DataUri.deprecate_constant(:DataFile)
 end

data/lib/shrine/plugins/default_storage.rb

@@ -2,28 +2,58 @@
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/default_storage.md] on GitHub.
-    #
-    # [doc/plugins/default_storage.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/default_storage.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/default_storage
     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 AttacherClassMethods
+        def default_cache(value = nil, &block)
+          default_storage.merge!(cache: value || block)
+        end
+
+        def default_store(value = nil, &block)
+          default_storage.merge!(store: value || block)
+        end
+
+        private
+
+        def default_storage
+          shrine_class.opts[:default_storage]
+        end
       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)
+            if @cache.arity == 2
+              Shrine.deprecation("Passing record & name argument to default storage block is deprecated and will be removed in Shrine 4. Use a block without arguments instead.")
+              @cache.call(record, name).to_sym
+            else
+              instance_exec(&@cache).to_sym
+            end
+          else
+            super
           end
+        end
 
-          super
+        def store_key
+          if @store.respond_to?(:call)
+            if @store.arity == 2
+              Shrine.deprecation("Passing record & name argument to default storage block is deprecated and will be removed in Shrine 4. Use a block without arguments instead.")
+              @store.call(record, name).to_sym
+            else
+              instance_exec(&@store).to_sym
+            end
+          else
+            super
+          end
         end
       end
     end

data/lib/shrine/plugins/default_url.rb

@@ -2,22 +2,16 @@
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/default_url.md] on GitHub.
-    #
-    # [doc/plugins/default_url.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/default_url.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/default_url
     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 +23,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,27 @@
 # 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
+    # Documentation can be found on https://shrinerb.com/docs/plugins/delete_raw
     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