shrine 2.19.4 → 3.0.0.alpha

data/lib/shrine/plugins/validation_helpers.rb

@@ -6,11 +6,6 @@ class Shrine
     #
     # [doc/plugins/validation_helpers.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/validation_helpers.md
     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 +19,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 +34,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 +54,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 +79,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 +89,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 +109,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 +119,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 +137,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 +149,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 +173,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 +185,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 +196,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 +208,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 +225,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,72 @@
 # 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
     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 +77,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 +88,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/storage/file_system.rb

@@ -6,7 +6,7 @@ require "pathname"
 class Shrine
   module Storage
     class FileSystem
-      attr_reader :directory, :prefix, :host, :permissions, :directory_permissions
+      attr_reader :directory, :prefix, :permissions, :directory_permissions
 
       # Initializes a storage for uploading to the filesystem.
       #
@@ -28,9 +28,7 @@ class Shrine
       # :  By default empty folders inside the directory are automatically
       #    deleted, but if it happens that it causes too much load on the
       #    filesystem, you can set this option to `false`.
-      def initialize(directory, prefix: nil, host: nil, clean: true, permissions: 0644, directory_permissions: 0755)
-        Shrine.deprecation("The :host option to Shrine::Storage::FileSystem#initialize is deprecated and will be removed in Shrine 3. Pass :host to FileSystem#url instead, you can also use default_url_options plugin.") if host
-
+      def initialize(directory, prefix: nil, clean: true, permissions: 0644, directory_permissions: 0755)
         if prefix
           @prefix = Pathname(relative(prefix))
           @directory = Pathname(directory).join(@prefix).expand_path
@@ -38,7 +36,6 @@ class Shrine
           @directory = Pathname(directory).expand_path
         end
 
-        @host = host
         @permissions = permissions
         @directory_permissions = directory_permissions
         @clean = clean
@@ -51,39 +48,21 @@ class Shrine
 
       # Copies the file into the given location.
       def upload(io, id, move: false, **)
-        if move && movable?(io, id)
-          move(io, id)
+        if move && movable?(io)
+          move(io, path!(id))
         else
           IO.copy_stream(io, path!(id))
-
-          path(id).chmod(permissions) if permissions
-        end
-      end
-
-      # Moves the file to the given location. This gets called by the `moving`
-      # plugin.
-      def move(io, id, **)
-        if io.respond_to?(:path)
-          FileUtils.mv io.path, path!(id)
-        else
-          FileUtils.mv io.storage.path(io.id), path!(id)
-          io.storage.clean(io.storage.path(io.id)) if io.storage.clean?
         end
 
         path(id).chmod(permissions) if permissions
       end
 
-      # Returns true if the file is a `File` or a UploadedFile uploaded by the
-      # FileSystem storage.
-      def movable?(io, id)
-        io.respond_to?(:path) ||
-          (io.is_a?(UploadedFile) && io.storage.is_a?(Storage::FileSystem))
-      end
-
       # Opens the file on the given location in read mode. Accepts additional
       # `File.open` arguments.
-      def open(id, **options, &block)
-        path(id).open(binmode: true, **options, &block)
+      def open(id, **options)
+        path(id).open(binmode: true, **options)
+      rescue Errno::ENOENT
+        raise Shrine::FileNotFound, "file #{id.inspect} not found on storage"
       end
 
       # Returns true if the file exists on the filesystem.
@@ -105,7 +84,7 @@ class Shrine
       # from the returned path (e.g. #directory can be set to "public" folder).
       # Both cases accept a `:host` value which will be prefixed to the
       # generated path.
-      def url(id, host: self.host, **options)
+      def url(id, host: nil, **options)
         path = (prefix ? relative_path(id) : path(id)).to_s
         host ? host + path : path
       end
@@ -115,15 +94,10 @@ class Shrine
       #
       #     file_system.clear! # deletes all files and subdirectories in the storage directory
       #     file_system.clear! { |path| path.mtime < Time.now - 7*24*60*60 } # deletes only files older than 1 week
-      def clear!(older_than: nil, &condition)
-        if older_than || condition
+      def clear!(&condition)
+        if condition
           list_files(directory) do |path|
-            if older_than
-              Shrine.deprecation("The :older_than option to FileSystem#clear! is deprecated and will be removed in Shrine 3. You should use a block instead, e.g. `storage.clear! { |path| path.mtime < Time.now - 7*24*60*60 }`.")
-              next unless path.mtime < older_than
-            else
-              next unless condition.call(path)
-            end
+            next unless condition.call(path)
             path.delete
             clean(path) if clean?
           end
@@ -137,15 +111,6 @@ class Shrine
         directory.join(id.gsub("/", File::SEPARATOR))
       end
 
-      # Catches the deprecated `#download` method.
-      def method_missing(name, *args, &block)
-        case name
-        when :download then deprecated_download(*args, &block)
-        else
-          super
-        end
-      end
-
       protected
 
       # Cleans all empty subdirectories up the hierarchy.
@@ -165,6 +130,24 @@ class Shrine
 
       private
 
+      # Moves the file to the given location. This gets called by the `moving`
+      # plugin.
+      def move(io, path)
+        if io.respond_to?(:path)
+          FileUtils.mv io.path, path
+        else
+          FileUtils.mv io.storage.path(io.id), path
+          io.storage.clean(io.storage.path(io.id)) if io.storage.clean?
+        end
+      end
+
+      # Returns true if the file is a `File` or a UploadedFile uploaded by the
+      # FileSystem storage.
+      def movable?(io)
+        io.respond_to?(:path) ||
+          (io.is_a?(UploadedFile) && io.storage.is_a?(Storage::FileSystem))
+      end
+
       # Creates all intermediate directories for that location.
       def path!(id)
         path = path(id)
@@ -191,20 +174,12 @@ class Shrine
           Dir.empty?(path)
         end
       else
+        # :nocov:
         def dir_empty?(path)
           Dir.foreach(path) { |x| return false unless [".", ".."].include?(x) }
           true
         end
-      end
-
-      def deprecated_download(id, **options)
-        Shrine.deprecation("Shrine::Storage::FileSystem#download is deprecated and will be removed in Shrine 3.")
-        tempfile = Tempfile.new(["shrine-filesystem", File.extname(id)], binmode: true)
-        open(id, **options) { |file| IO.copy_stream(file, tempfile) }
-        tempfile.tap(&:open)
-      rescue
-        tempfile.close! if tempfile
-        raise
+        # :nocov:
       end
     end
   end