shrine 2.19.4 → 3.4.0

data/lib/shrine/plugins/validation.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # Documentation can be found on https://shrinerb.com/docs/plugins/validation
+    module Validation
+      module AttacherClassMethods
+        # Block that is executed in context of Shrine::Attacher during
+        # validation. Example:
+        #
+        #     Shrine::Attacher.validate do
+        #       if file.size > 5*1024*1024
+        #         errors << "is too big (max is 5 MB)"
+        #       end
+        #     end
+        def validate(&block)
+          private define_method(:validate_block, &block)
+        end
+      end
+
+      module AttacherMethods
+        # Returns an array of validation errors created on file assignment in
+        # the `Attacher.validate` block.
+        attr_reader :errors
+
+        # Initializes validation errors to an empty array.
+        def initialize(**options)
+          super
+          @errors = []
+        end
+
+        # Performs validations after attaching cached file.
+        def attach_cached(value, validate: nil, **options)
+          result = super(value, validate: false, **options)
+          validation(validate)
+          result
+        end
+
+        # Performs validations after attaching file.
+        def attach(io, validate: nil, **options)
+          result = super(io, **options)
+          validation(validate)
+          result
+        end
+
+        # Runs the validation defined by `Attacher.validate`.
+        def validate(**options)
+          errors.clear
+          _validate(**options) if attached?
+        end
+
+        private
+
+        # Calls validation appropriately based on the :validate value.
+        def validation(argument)
+          case argument
+          when Hash  then validate(**argument)
+          when false then errors.clear # skip validation
+          else            validate
+          end
+        end
+
+        # Calls #validate_block, passing it accepted parameters.
+        def _validate(**options)
+          if method(:validate_block).arity.zero?
+            validate_block
+          else
+            validate_block(**options)
+          end
+        end
+
+        # Overridden by the `Attacher.validate` block.
+        def validate_block(**options)
+        end
+      end
+    end
+
+    register_plugin(:validation, Validation)
+  end
+end

data/lib/shrine/plugins/validation_helpers.rb

@@ -2,15 +2,8 @@
 
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/validation_helpers.md] on GitHub.
-    #
-    # [doc/plugins/validation_helpers.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/validation_helpers.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/validation_helpers
     module ValidationHelpers
-      def self.configure(uploader, opts = {})
-        uploader.opts[:validation_default_messages] ||= {}
-        uploader.opts[:validation_default_messages].merge!(opts[:default_messages] || {})
-      end
-
       DEFAULT_MESSAGES = {
         max_size:            -> (max)  { "size must not be greater than #{PRETTY_FILESIZE.call(max)}" },
         min_size:            -> (min)  { "size must not be less than #{PRETTY_FILESIZE.call(min)}" },
@@ -24,7 +17,7 @@ class Shrine
         mime_type_exclusion: -> (list) { "type must not be one of: #{list.join(", ")}" },
         extension_inclusion: -> (list) { "extension must be one of: #{list.join(", ")}" },
         extension_exclusion: -> (list) { "extension must not be one of: #{list.join(", ")}" },
-      }
+      }.freeze
 
       FILESIZE_UNITS = ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"].freeze
 
@@ -39,10 +32,18 @@ class Shrine
         "%.1f %s" % [bytes.to_f / 1024 ** exp, FILESIZE_UNITS[exp]]
       end
 
+      def self.load_dependencies(uploader, *)
+        uploader.plugin :validation
+      end
+
+      def self.configure(uploader, default_messages: {}, **opts)
+        uploader.opts[:validation_helpers] ||= { default_messages: DEFAULT_MESSAGES.dup }
+        uploader.opts[:validation_helpers][:default_messages].merge!(default_messages)
+      end
+
       module AttacherClassMethods
         def default_validation_messages
-          @default_validation_messages ||= DEFAULT_MESSAGES.merge(
-            shrine_class.opts[:validation_default_messages])
+          shrine_class.opts[:validation_helpers][:default_messages]
         end
       end
 
@@ -51,14 +52,14 @@ class Shrine
         #
         #     validate_max_size 5*1024*1024
         def validate_max_size(max, message: nil)
-          validate_result(get.size <= max, :max_size, message, max)
+          validate_result(file.size <= max, :max_size, message, max)
         end
 
         # Validates that the `size` metadata is not smaller than `min`.
         #
         #     validate_min_size 1024
         def validate_min_size(min, message: nil)
-          validate_result(get.size >= min, :min_size, message, min)
+          validate_result(file.size >= min, :min_size, message, min)
         end
 
         # Validates that the `size` metadata is in the given range.
@@ -76,12 +77,9 @@ class Shrine
         #
         #     validate_max_width 5000
         def validate_max_width(max, message: nil)
-          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:width)
-          if get.width
-            validate_result(get.width <= max, :max_width, message, max)
-          else
-            Shrine.deprecation("Width of the uploaded file is nil, and Shrine skipped the validation. In Shrine 3 the validation will fail if width is nil.")
-          end
+          fail Error, "width metadata is missing" unless file["width"]
+
+          validate_result(file["width"] <= max, :max_width, message, max)
         end
 
         # Validates that the `width` metadata is not smaller than `min`.
@@ -89,12 +87,9 @@ class Shrine
         #
         #     validate_min_width 100
         def validate_min_width(min, message: nil)
-          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:width)
-          if get.width
-            validate_result(get.width >= min, :min_width, message, min)
-          else
-            Shrine.deprecation("Width of the uploaded file is nil, and Shrine skipped the validation. In Shrine 3 the validation will fail if width is nil.")
-          end
+          fail Error, "width metadata is missing" unless file["width"]
+
+          validate_result(file["width"] >= min, :min_width, message, min)
         end
 
         # Validates that the `width` metadata is in the given range.
@@ -112,12 +107,9 @@ class Shrine
         #
         #     validate_max_height 5000
         def validate_max_height(max, message: nil)
-          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:height)
-          if get.height
-            validate_result(get.height <= max, :max_height, message, max)
-          else
-            Shrine.deprecation("Height of the uploaded file is nil, and Shrine skipped the validation. In Shrine 3 the validation will fail if height is nil.")
-          end
+          fail Error, "height metadata is missing" unless file["height"]
+
+          validate_result(file["height"] <= max, :max_height, message, max)
         end
 
         # Validates that the `height` metadata is not smaller than `min`.
@@ -125,12 +117,9 @@ class Shrine
         #
         #     validate_min_height 100
         def validate_min_height(min, message: nil)
-          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:height)
-          if get.height
-            validate_result(get.height >= min, :min_height, message, min)
-          else
-            Shrine.deprecation("Height of the uploaded file is nil, and Shrine skipped the validation. In Shrine 3 the validation will fail if height is nil.")
-          end
+          fail Error, "height metadata is missing" unless file["height"]
+
+          validate_result(file["height"] >= min, :min_height, message, min)
         end
 
         # Validates that the `height` metadata is in the given range.
@@ -146,11 +135,10 @@ class Shrine
         #
         #     validate_max_dimensions [5000, 5000]
         def validate_max_dimensions((max_width, max_height), message: nil)
-          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:width) && get.respond_to?(:height)
-          fail Error, "width or height metadata is nil" unless get.width && get.height
+          fail Error, "width and/or height metadata is missing" unless file["width"] && file["height"]
 
           validate_result(
-            get.width <= max_width && get.height <= max_height,
+            file["width"] <= max_width && file["height"] <= max_height,
             :max_dimensions, message, [max_width, max_height]
           )
         end
@@ -159,11 +147,10 @@ class Shrine
         #
         #     validate_max_dimensions [100, 100]
         def validate_min_dimensions((min_width, min_height), message: nil)
-          fail Error, ":store_dimensions plugin is required" unless get.respond_to?(:width) && get.respond_to?(:height)
-          fail Error, "width or height metadata is nil" unless get.width && get.height
+          fail Error, "width and/or height metadata is missing" unless file["width"] && file["height"]
 
           validate_result(
-            get.width >= min_width && get.height >= min_height,
+            file["width"] >= min_width && file["height"] >= min_height,
             :min_dimensions, message, [min_width, min_height]
           )
         end
@@ -184,7 +171,7 @@ class Shrine
         #     validate_mime_type_inclusion %w[audio/mp3 audio/flac]
         def validate_mime_type_inclusion(types, message: nil)
           validate_result(
-            types.any? { |type| regex(type) =~ get.mime_type.to_s },
+            types.include?(file.mime_type),
             :mime_type_inclusion, message, types
           )
         end
@@ -196,7 +183,7 @@ class Shrine
         #     validate_mime_type_exclusion %w[text/x-php]
         def validate_mime_type_exclusion(types, message: nil)
           validate_result(
-            types.none? { |type| regex(type) =~ get.mime_type.to_s },
+            !types.include?(file.mime_type),
             :mime_type_exclusion, message, types
           )
         end
@@ -207,7 +194,7 @@ class Shrine
         #     validate_extension_inclusion %w[jpg jpeg png gif]
         def validate_extension_inclusion(extensions, message: nil)
           validate_result(
-            extensions.any? { |extension| regex(extension) =~ get.extension.to_s },
+            extensions.any? { |extension| extension.casecmp(file.extension.to_s) == 0 },
             :extension_inclusion, message, extensions
           )
         end
@@ -219,7 +206,7 @@ class Shrine
         #     validate_extension_exclusion %[php jar]
         def validate_extension_exclusion(extensions, message: nil)
           validate_result(
-            extensions.none? { |extension| regex(extension) =~ get.extension.to_s },
+            extensions.none? { |extension| extension.casecmp(file.extension.to_s) == 0 },
             :extension_exclusion, message, extensions
           )
         end
@@ -236,16 +223,6 @@ class Shrine
           end
         end
 
-        # Converts a string to a regex.
-        def regex(value)
-          if value.is_a?(Regexp)
-            Shrine.deprecation("Passing regexes to type/extension whitelists/blacklists in validation_helpers plugin is deprecated and will be removed in Shrine 3. Use strings instead.")
-            value
-          else
-            /\A#{Regexp.escape(value)}\z/i
-          end
-        end
-
         # Generates an error message and appends it to errors array.
         def add_error(*args)
           errors << error_message(*args)

data/lib/shrine/plugins/versions.rb

@@ -1,113 +1,70 @@
 # frozen_string_literal: true
 
+Shrine.deprecation("The versions plugin is deprecated and will be removed in Shrine 4. Use the new derivatives plugin instead.")
+
 class Shrine
   module Plugins
-    # Documentation lives in [doc/plugins/versions.md] on GitHub.
-    #
-    # [doc/plugins/versions.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/versions.md
+    # Documentation can be found on https://shrinerb.com/docs/plugins/versions
     module Versions
-      def self.load_dependencies(uploader, *)
+      def self.load_dependencies(uploader, **)
+        uploader.plugin :processing
         uploader.plugin :default_url
       end
 
-      def self.configure(uploader, opts = {})
-        Shrine.deprecation("The versions Shrine plugin doesn't need the :names option anymore, you can safely remove it.") if opts.key?(:names)
-
-        uploader.opts[:version_names] = opts.fetch(:names, uploader.opts[:version_names])
-        uploader.opts[:version_fallbacks] = opts.fetch(:fallbacks, uploader.opts.fetch(:version_fallbacks, {}))
-        uploader.opts[:versions_fallback_to_original] = opts.fetch(:fallback_to_original, uploader.opts.fetch(:versions_fallback_to_original, true))
+      def self.configure(uploader, **opts)
+        uploader.opts[:versions] ||= { fallbacks: {}, fallback_to_original: true }
+        uploader.opts[:versions].merge!(opts)
       end
 
       module ClassMethods
-        def version_names
-          Shrine.deprecation("Shrine.version_names is deprecated and will be removed in Shrine 3.")
-          opts[:version_names]
-        end
-
         def version_fallbacks
-          opts[:version_fallbacks]
-        end
-
-        # Checks that the identifier is a registered version.
-        def version?(name)
-          Shrine.deprecation("Shrine.version? is deprecated and will be removed in Shrine 3.")
-          version_names.nil? || version_names.map(&:to_s).include?(name.to_s)
+          opts[:versions][:fallbacks]
         end
 
         # Converts a hash of data into a hash of versions.
-        def uploaded_file(object, &block)
-          if object.is_a?(Hash) && object.values.none? { |value| value.is_a?(String) }
-            object.inject({}) do |result, (name, value)|
-              result.merge!(name.to_sym => uploaded_file(value, &block))
+        def uploaded_file(object)
+          object = JSON.parse(object) if object.is_a?(String)
+
+          Utils.deep_map(object, transform_keys: :to_sym) do |path, value|
+            if value.is_a?(Hash) && (value["id"].is_a?(String) || value[:id].is_a?(String))
+              file = super(value)
+            elsif value.is_a?(UploadedFile)
+              file = value
+            end
+
+            if file
+              yield file if block_given?
+              file
             end
-          elsif object.is_a?(Array)
-            object.map { |value| uploaded_file(value, &block) }
-          else
-            super
           end
         end
       end
 
       module InstanceMethods
-        # Checks whether all versions are uploaded by this uploader.
-        def uploaded?(object)
-          if object.is_a?(Hash)
-            object.all? { |name, version| uploaded?(version) }
-          elsif object.is_a?(Array)
-            object.all? { |version| uploaded?(version) }
-          else
-            super
-          end
-        end
+        def upload(io, **options)
+          files = process(io, **options) || io
 
-        private
-
-        # Stores each version individually. It asserts that all versions are
-        # known, because later the versions will be silently filtered, so
-        # we want to let the user know that they forgot to register a new
-        # version.
-        def _store(io, context)
-          if (hash = io).is_a?(Hash)
-            raise Error, ":location is not applicable to versions" if context.key?(:location)
-            raise Error, "detected multiple versions that point to the same IO object: given versions: #{hash.keys}, unique versions: #{hash.invert.invert.keys}" if hash.invert.invert != hash
-
-            hash.inject({}) do |result, (name, value)|
-              result.merge!(name.to_sym => _store(value, context.merge(version: name.to_sym){|_, v1, v2| Array(v1) + Array(v2)}))
-            end
-          elsif (array = io).is_a?(Array)
-            array.map.with_index { |value, idx| _store(value, context.merge(version: idx){|_, v1, v2| Array(v1) + Array(v2)}) }
-          else
-            super
-          end
-        end
+          Utils.map_file(files) do |name, version|
+            options.merge!(version: name.one? ? name.first : name) if name
 
-        # Deletes each file individually
-        def _delete(uploaded_file, context)
-          if (hash = uploaded_file).is_a?(Hash)
-            hash.each do |name, value|
-              _delete(value, context)
-            end
-          elsif (array = uploaded_file).is_a?(Array)
-            array.each do |value|
-              _delete(value, context)
-            end
-          else
-            super
+            super(version, **options, process: false)
           end
         end
       end
 
       module AttacherMethods
+        def destroy(*)
+          Utils.each_file(self.file) { |_, file| file.delete }
+        end
+
         # Smart versioned URLs, which include the version name in the default
         # URL, and properly forwards any options to the underlying storage.
         def url(version = nil, **options)
-          attachment = get
-
-          if attachment.is_a?(Hash)
+          if file.is_a?(Hash)
             if version
               version = version.to_sym
-              if attachment.key?(version)
-                attachment[version].url(**options)
+              if file.key?(version)
+                file[version].url(**options)
               elsif fallback = shrine_class.version_fallbacks[version]
                 url(fallback, **options)
               else
@@ -118,8 +75,8 @@ class Shrine
             end
           else
             if version
-              if attachment && fallback_to_original?
-                attachment.url(**options)
+              if file && shrine_class.opts[:versions][:fallback_to_original]
+                file.url(**options)
               else
                 default_url(**options, version: version)
               end
@@ -129,22 +86,85 @@ class Shrine
           end
         end
 
+        # Converts the Hash/Array of UploadedFile objects into a Hash/Array of data.
+        def data
+          Utils.map_file(file, transform_keys: :to_s) do |_, version|
+            version.data
+          end
+        end
+
+        def file=(file)
+          if file.is_a?(Hash) || file.is_a?(Array)
+            @file = file
+          else
+            super
+          end
+        end
+
+        def uploaded_file(value, &block)
+          shrine_class.uploaded_file(value, &block)
+        end
+
         private
 
-        def fallback_to_original?
-          shrine_class.opts[:versions_fallback_to_original]
+        def uploaded?(file, storage_key)
+          if file.is_a?(Hash) || file.is_a?(Array)
+            Utils.each_file(file).all? { |_, f| f.storage_key == storage_key }
+          else
+            super
+          end
         end
+      end
 
-        # Converts the Hash/Array of UploadedFile objects into a Hash/Array of data.
-        def convert_to_data(object)
+      module Utils
+        module_function
+
+        def each_file(object)
+          return enum_for(__method__, object) unless block_given?
+
+          map_file(object) do |path, file|
+            yield path, file
+            file
+          end
+        end
+
+        def map_file(object, transform_keys: :to_sym)
+          if object.is_a?(Hash) || object.is_a?(Array)
+            deep_map(object, transform_keys: transform_keys) do |path, value|
+              yield path, value unless value.is_a?(Hash) || value.is_a?(Array)
+            end
+          elsif object
+            yield nil, object
+          else
+            object
+          end
+        end
+
+        def deep_map(object, path = [], transform_keys:, &block)
           if object.is_a?(Hash)
-            object.inject({}) do |hash, (name, value)|
-              hash.merge!(name => convert_to_data(value))
+            result = yield path, object
+
+            return result if result
+
+            object.inject({}) do |hash, (key, value)|
+              key    = key.send(transform_keys)
+              result = yield [*path, key], value
+
+              hash.merge! key => (result || deep_map(value, [*path, key], transform_keys: transform_keys, &block))
             end
           elsif object.is_a?(Array)
-            object.map { |value| convert_to_data(value) }
+            result = yield path, object
+
+            return result if result
+
+            object.map.with_index do |value, idx|
+              result = yield [*path, idx], value
+
+              result || deep_map(value, [*path, idx], transform_keys: transform_keys, &block)
+            end
           else
-            super
+            result = yield path, object
+            result or fail Shrine::Error, "leaf reached"
           end
         end
       end

data/lib/shrine/plugins.rb

@@ -18,6 +18,28 @@ class Shrine
       plugin
     end
 
+    # Delegate call to the plugin in a way that works across Ruby versions.
+    def self.load_dependencies(plugin, uploader, *args, **kwargs, &block)
+      return unless plugin.respond_to?(:load_dependencies)
+
+      if kwargs.any?
+        plugin.load_dependencies(uploader, *args, **kwargs, &block)
+      else
+        plugin.load_dependencies(uploader, *args, &block)
+      end
+    end
+
+    # Delegate call to the plugin in a way that works across Ruby versions.
+    def self.configure(plugin, uploader, *args, **kwargs, &block)
+      return unless plugin.respond_to?(:configure)
+
+      if kwargs.any?
+        plugin.configure(uploader, *args, **kwargs, &block)
+      else
+        plugin.configure(uploader, *args, &block)
+      end
+    end
+
     # Register the given plugin with Shrine, so that it can be loaded using
     # `Shrine.plugin` with a symbol. Should be used by plugin files. Example:
     #