shrine 1.4.2 → 2.0.0

data/lib/shrine/plugins/remote_url.rb

@@ -15,65 +15,54 @@ class Shrine
     #     user.avatar.size              #=> 43423
     #     user.avatar.original_filename #=> "cool-image.png"
     #
-    # The file will by default be downloaded using Ruby's open-uri standard
-    # library. Following redirects is disabled for security reasons. It's also
-    # good practice to limit the filesize of the remote file:
+    # The file will by default be downloaded using [Down], which is a wrapper
+    # around the open-uri standard library. It's a good practice to limit the
+    # maximum filesize of the remote file:
     #
     #     plugin :remote_url, max_size: 20*1024*1024 # 20 MB
     #
-    # Now if a file that is bigger than 20MB is assigned, Shrine will terminate
-    # the download as soon as it gets the "Content-Length" header, or the
-    # buffer size surpasses the maximum size. However, if for whatever reason
-    # you don't want to limit the maximum file size, you can set `:max_size` to
-    # nil:
+    # Now if a file that is bigger than 20MB is assigned, download will be
+    # terminated as soon as it gets the "Content-Length" header, or the
+    # size of currently downloaded content surpasses the maximum size.
+    # However, if for whatever reason you don't want to limit the maximum file
+    # size, you can set `:max_size` to nil:
     #
     #     plugin :remote_url, max_size: nil
     #
-    # Finally, if for some reason the way the file is downloaded doesn't suit
-    # your needs, you can provide a custom downloader:
+    # If you need to additionally customize how the file is downloaded, you can
+    # override the `:downloader`:
     #
-    #     plugin :remote_url, downloader: ->(url, max_size:) do
-    #       request = RestClient::Request.new(method: :get, url: url, raw_response: true)
-    #       response = request.execute
-    #       response.file
+    #     plugin :remote_url, max_size: 20*1024*1024, downloader: ->(url, max_size:) do
+    #       Down.download(url, max_size: max_size, max_redirects: 4, read_timeout: 3)
     #     end
     #
     # If download errors, the error is rescued and a validation error is added
     # equal to the error message. You can change the default error message:
     #
     #     plugin :remote_url, error_message: "download failed"
-    #     plugin :remote_url, error_message: ->(url) { I18n.t("errors.download_failed") }
+    #     plugin :remote_url, error_message: ->(url, error) { I18n.t("errors.download_failed") }
     #
-    # If you need the error instance for generating the error message, passing
-    # the `:include_error` option will additionally yield the error to the
-    # block:
-    #
-    #     plugin :remote_url, include_error: true, error_message: ->(url, error) { "..." }
+    # [Down]: https://github.com/janko-m/down
     module RemoteUrl
-      def self.load_dependencies(uploader, downloader: :open_uri, **)
-        case downloader
-        when :open_uri then require "down"
-        end
-      end
+      def self.configure(uploader, opts = {})
+        raise Error, "The :max_size option is required for remote_url plugin" if !opts.key?(:max_size) && !uploader.opts.key?(:remote_url_max_size)
 
-      def self.configure(uploader, downloader: :open_uri, max_size:, error_message: nil, include_error: false)
-        uploader.opts[:remote_url_downloader] = downloader
-        uploader.opts[:remote_url_max_size] = max_size
-        uploader.opts[:remote_url_error_message] = error_message
-        uploader.opts[:remote_url_include_error] = include_error
+        uploader.opts[:remote_url_downloader] = opts.fetch(:downloader, uploader.opts.fetch(:remote_url_downloader, :open_uri))
+        uploader.opts[:remote_url_max_size] = opts.fetch(:max_size, uploader.opts[:remote_url_max_size])
+        uploader.opts[:remote_url_error_message] = opts.fetch(:error_message, uploader.opts[:remote_url_error_message])
       end
 
       module AttachmentMethods
-        def initialize(name)
+        def initialize(*)
           super
 
           module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def #{name}_remote_url=(url)
-              #{name}_attacher.remote_url = url
+            def #{@name}_remote_url=(url)
+              #{@name}_attacher.remote_url = url
             end
 
-            def #{name}_remote_url
-              #{name}_attacher.remote_url
+            def #{@name}_remote_url
+              #{@name}_attacher.remote_url
             end
           RUBY
         end
@@ -113,26 +102,25 @@ class Shrine
         # is too big.
         def download(url)
           downloader = shrine_class.opts[:remote_url_downloader]
+          downloader = method(:"download_with_#{downloader}") if downloader.is_a?(Symbol)
           max_size = shrine_class.opts[:remote_url_max_size]
 
-          if downloader.is_a?(Symbol)
-            send(:"download_with_#{downloader}", url, max_size: max_size)
-          else
-            downloader.call(url, max_size: max_size)
-          end
+          downloader.call(url, max_size: max_size)
         end
 
         # We silence any download errors, because for the user's point of view
         # the download simply failed.
         def download_with_open_uri(url, max_size:)
+          require "down"
           Down.download(url, max_size: max_size)
         end
 
         def download_error_message(url, error)
           if message = shrine_class.opts[:remote_url_error_message]
-            args = [url]
-            args << error if shrine_class.opts[:remote_url_include_error]
-            message = message.call(*args) if message.respond_to?(:call)
+            if message.respond_to?(:call)
+              args = [url, error].take(message.arity.abs)
+              message = message.call(*args)
+            end
           else
             message = "download failed"
             message = "#{message}: #{error.message}" if error

data/lib/shrine/plugins/remove_attachment.rb

@@ -20,16 +20,16 @@ class Shrine
     # declared somewhere after the hidden field.
     module RemoveAttachment
       module AttachmentMethods
-        def initialize(name)
+        def initialize(*)
           super
 
           module_eval <<-RUBY, __FILE__, __LINE__ + 1
-            def remove_#{name}=(value)
-              #{name}_attacher.remove = value
+            def remove_#{@name}=(value)
+              #{@name}_attacher.remove = value
             end
 
-            def remove_#{name}
-              #{name}_attacher.remove
+            def remove_#{@name}
+              #{@name}_attacher.remove
             end
           RUBY
         end

data/lib/shrine/plugins/remove_invalid.rb

@@ -10,7 +10,7 @@ class Shrine
           super
         ensure
           if errors.any? && cache.uploaded?(get)
-            delete!(get, phase: :invalid)
+            _delete(get, phase: :validate)
             _set(nil)
           end
         end

data/lib/shrine/plugins/restore_cached_data.rb

@@ -1,14 +1,9 @@
 class Shrine
   module Plugins
-    # The restore_cached_data plugin ensures the cached file data hasn't been
-    # tampered with, by restoring the metadata after assignment. The user can
-    # tamper with the cached file data by modifying the hidden field before
-    # submitting the form.
-    #
-    # Firstly the assignment is terminated if the cached file doesn't exist,
-    # which can happen if the user changes the "id" or "storage" data. If the
-    # cached file exists, the metadata is reextracted from the original file
-    # and replaced with the potentially tampered with ones.
+    # The restore_cached_data plugin ensures the cached file metadata hasn't
+    # been tampered with, which can be done by modifying the hidden field
+    # before submitting the form. The cached file's metadata will be
+    # reextracted during assignment and replaced with potentially tampered one.
     #
     #     plugin :restore_cached_data
     module RestoreCachedData
@@ -18,7 +13,6 @@ class Shrine
         def assign_cached(value)
           cached_file = uploaded_file(value) do |cached_file|
             next unless cache.uploaded?(cached_file)
-            return unless cached_file.exists?
             real_metadata = cache.extract_metadata(cached_file.to_io, context)
             cached_file.metadata.update(real_metadata)
             cached_file.close

data/lib/shrine/plugins/sequel.rb

@@ -1,7 +1,5 @@
 require "sequel"
 
-Sequel::Model.plugin :instance_filters
-
 class Shrine
   module Plugins
     # The sequel plugin extends the "attachment" interface with support for
@@ -9,10 +7,11 @@ class Shrine
     #
     #     plugin :sequel
     #
-    # Now whenever an "attachment" module is included, additional callbacks are
-    # added to the model:
+    # ## Callbacks
+    #
+    # Now the attachment module will add additional callbacks to the model:
     #
-    # * `before_save` -- Currently only used by the recache plugin.
+    # * `before_save` -- Used by the recached plugin.
     # * `after_commit` -- Promotes the attachment, deletes replaced ones.
     # * `after_destroy_commit` -- Deletes the attachment.
     #
@@ -20,8 +19,29 @@ class Shrine
     # `after_commit` callbacks won't get called, so in order to test uploading
     # you should first disable transactions for those tests.
     #
-    # If you want to put some parts of this lifecycle into a background job,
-    # see the backgrounding plugin.
+    # If you want to put promoting/deleting into a background job, see the
+    # backgrounding plugin.
+    #
+    # Since attaching first saves the record with a cached attachment, then
+    # saves again with a stored attachment, you can detect this in callbacks:
+    #
+    #     class User < Sequel::Model
+    #       include ImageUploader[:avatar]
+    #
+    #       def before_save
+    #         super
+    #
+    #         if changed_columns.include?(:avatar) && avatar_attacher.cached?
+    #           # cached
+    #         end
+    #
+    #         if changed_columns.include?(:avatar) && avatar_attacher.stored?
+    #           # promoted
+    #         end
+    #       end
+    #     end
+    #
+    # ## Validations
     #
     # Additionally, any Shrine validation errors will added to Sequel's
     # errors upon validation. Note that if you want to validate presence of the
@@ -33,30 +53,32 @@ class Shrine
     #     end
     module Sequel
       module AttachmentMethods
-        def initialize(name)
+        def included(model)
           super
 
-          class_eval <<-RUBY, __FILE__, __LINE__ + 1
+          return unless model < ::Sequel::Model
+
+          module_eval <<-RUBY, __FILE__, __LINE__ + 1
             def validate
               super
-              #{name}_attacher.errors.each do |message|
-                errors.add(:#{name}, message)
+              #{@name}_attacher.errors.each do |message|
+                errors.add(:#{@name}, message)
               end
             end
 
             def before_save
               super
-              #{name}_attacher.save if #{name}_attacher.attached?
+              #{@name}_attacher.save if #{@name}_attacher.attached?
             end
 
             def after_commit
               super
-              #{name}_attacher.finalize if #{name}_attacher.attached?
+              #{@name}_attacher.finalize if #{@name}_attacher.attached?
             end
 
             def after_destroy_commit
               super
-              #{name}_attacher.destroy
+              #{@name}_attacher.destroy
             end
           RUBY
         end
@@ -72,18 +94,21 @@ class Shrine
       module AttacherMethods
         private
 
-        # Updates the current attachment with the new one, unless the current
-        # attachment has changed.
-        def update(uploaded_file)
-          if record.send("#{name}_data") == record.reload.send("#{name}_data")
-            record.send("#{name}_data=", uploaded_file.to_json)
-            record.save(validate: false)
-          end
+        # Proceeds with updating the record unless the attachment has changed.
+        def swap(uploaded_file)
+          return if record.send(:"#{name}_data") != record.reload.send(:"#{name}_data")
+          super
         rescue ::Sequel::NoExistingObject
         rescue ::Sequel::Error => error
           raise unless error.message == "Record not found" # prior to version 4.28
         end
 
+        # Saves the record after assignment, skipping validations.
+        def update(uploaded_file)
+          super
+          record.save(validate: false)
+        end
+
         # Support for Postgres JSON columns.
         def read
           value = super

data/lib/shrine/plugins/store_dimensions.rb

@@ -17,21 +17,16 @@ class Shrine
     # if for some reason it doesn't suit your needs, you can provide a custom
     # `:analyzer`:
     #
-    #     plugin :store_dimensions, analyzer: ->(io) do
-    #       MiniMagick::Image.new(io).dimensions #=> [300, 500]
+    #     plugin :store_dimensions, analyzer: ->(io, analyzers) do
+    #       dimensions = analyzers[:fastimage].call(io)
+    #       dimensions || MiniMagick::Image.new(io).dimensions
     #     end
     #
     # [fastimage]: https://github.com/sdsykes/fastimage
     # [image bombs]: https://www.bamsoftware.com/hacks/deflate.html
     module StoreDimensions
-      def self.load_dependencies(uploader, analyzer: :fastimage)
-        case analyzer
-        when :fastimage then require "fastimage"
-        end
-      end
-
-      def self.configure(uploader, analyzer: :fastimage)
-        uploader.opts[:dimensions_analyzer] = analyzer
+      def self.configure(uploader, opts = {})
+        uploader.opts[:dimensions_analyzer] = opts.fetch(:analyzer, uploader.opts.fetch(:dimensions_analyzer, :fastimage))
       end
 
       module InstanceMethods
@@ -45,28 +40,32 @@ class Shrine
           )
         end
 
+        private
+
         # If the `io` is an uploaded file, copies its dimensions, otherwise
         # calls the predefined or custom analyzer.
         def extract_dimensions(io)
           analyzer = opts[:dimensions_analyzer]
+          analyzer = dimensions_analyzers[analyzer] if analyzer.is_a?(Symbol)
+          args = [io, dimensions_analyzers].take(analyzer.arity.abs)
 
-          dimensions = if io.respond_to?(:width) && io.respond_to?(:height)
-            [io.width, io.height]
-          elsif analyzer.is_a?(Symbol)
-            send(:"_extract_dimensions_with_#{analyzer}", io)
-          else
-            analyzer.call(io)
-          end
-
+          dimensions = analyzer.call(*args)
           io.rewind
 
           dimensions
         end
 
-        private
+        def dimensions_analyzers
+          Hash.new { |hash, key| method(:"_extract_dimensions_with_#{key}") }
+        end
 
         def _extract_dimensions_with_fastimage(io)
-          FastImage.size(io)
+          require "fastimage"
+
+          dimensions = FastImage.size(io)
+          io.rewind
+
+          dimensions
         end
       end
 

data/lib/shrine/plugins/upload_options.rb

@@ -1,7 +1,12 @@
 class Shrine
   module Plugins
-    # The upload_options allows you to create additional upload options depending
-    # on file and context, and forward them to the underlying storage.
+    # The upload_options allows you to automatically pass additional upload
+    # options to storage on every upload:
+    #
+    #     plugin :upload_options, cache: {acl: "private"}
+    #
+    # Keys are names of the registered storages, and values are either hashes
+    # or blocks.
     #
     #     plugin :upload_options, store: ->(io, context) do
     #       if [:original, :thumb].include?(context[:version])
@@ -10,26 +15,23 @@ class Shrine
     #         {acl: "private"}
     #       end
     #     end
-    #
-    # Keys are names of the registered storages, and values are either blocks
-    # or hashes.
     module UploadOptions
       def self.configure(uploader, options = {})
-        uploader.opts[:upload_options_options] = options
+        uploader.opts[:upload_options] ||= {}
+        options.each { |key, value| uploader.opts[:upload_options][key] = value }
       end
 
       module InstanceMethods
         def put(io, context)
           upload_options = get_upload_options(io, context)
-          key = storage.class.name.split("::").last.downcase
-          context[:metadata][key] = upload_options if upload_options
+          context = {upload_options: upload_options}.merge(context)
           super
         end
 
         private
 
         def get_upload_options(io, context)
-          options = opts[:upload_options_options][storage_key]
+          options = opts[:upload_options][storage_key]
           options = options.call(io, context) if options.respond_to?(:call)
           options
         end

data/lib/shrine/plugins/validation_helpers.rb

@@ -32,8 +32,8 @@ class Shrine
     #
     # For a complete list of all validation helpers, see AttacherMethods.
     module ValidationHelpers
-      def self.configure(uploader, default_messages: {})
-        uploader.opts[:validation_helpers_default_messages] = default_messages
+      def self.configure(uploader, opts = {})
+        uploader.opts[:validation_default_messages] = (uploader.opts[:validation_default_messages] || {}).merge(opts[:default_messages] || {})
       end
 
       DEFAULT_MESSAGES = {
@@ -52,7 +52,7 @@ class Shrine
       module AttacherClassMethods
         def default_validation_messages
           @default_validation_messages ||= DEFAULT_MESSAGES.merge(
-            shrine_class.opts[:validation_helpers_default_messages])
+            shrine_class.opts[:validation_default_messages])
         end
       end
 

data/lib/shrine/plugins/versions.rb

@@ -22,6 +22,18 @@ class Shrine
     #       end
     #     end
     #
+    # Note that if you want to keep the original file, you can forward it as is
+    # without explicitly downloading it (since `Shrine::UploadedFile` itself is
+    # an IO-like object), which might avoid downloading depending on the
+    # storage:
+    #
+    #     def process(io, context)
+    #       if context[:phase] == :store
+    #         # ...
+    #         {original: io, thumb: thumb}
+    #       end
+    #     end
+    #
     # Now when you access the stored attachment through the model, a hash of
     # uploaded files will be returned:
     #
@@ -96,11 +108,14 @@ class Shrine
     module Versions
       def self.load_dependencies(uploader, *)
         uploader.plugin :multi_delete
+        uploader.plugin :default_url
       end
 
-      def self.configure(uploader, names:, fallbacks: {})
-        uploader.opts[:version_names] = names
-        uploader.opts[:version_fallbacks] = fallbacks
+      def self.configure(uploader, opts = {})
+        uploader.opts[:version_names] = opts.fetch(:names, uploader.opts[:version_names])
+        uploader.opts[:version_fallbacks] = opts.fetch(:fallbacks, uploader.opts.fetch(:version_fallbacks, {}))
+
+        raise Error, "The :names option is required for versions plugin" if uploader.opts[:version_names].nil?
       end
 
       module ClassMethods