shrine 2.19.3 → 3.6.0

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:
     #

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.
@@ -91,6 +70,16 @@ class Shrine
         path(id).exist?
       end
 
+      # If #prefix is not present, returns a path composed of #directory and
+      # the given `id`. If #prefix is present, it excludes the #directory part
+      # 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: nil, **options)
+        path = (prefix ? relative_path(id) : path(id)).to_s
+        host ? host + path : path
+      end
+
       # Delets the file, and by default deletes the containing directory if
       # it's empty.
       def delete(id)
@@ -100,14 +89,11 @@ class Shrine
       rescue Errno::ENOENT
       end
 
-      # If #prefix is not present, returns a path composed of #directory and
-      # the given `id`. If #prefix is present, it excludes the #directory part
-      # 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)
-        path = (prefix ? relative_path(id) : path(id)).to_s
-        host ? host + path : path
+      # Deletes the specified directory on the filesystem.
+      #
+      #    file_system.delete_prefixed("somekey/derivatives/")
+      def delete_prefixed(delete_prefix)
+        FileUtils.rm_rf directory.join(delete_prefix)
       end
 
       # Deletes all files from the #directory. If a block is passed in, deletes
@@ -115,15 +101,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 +118,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 +137,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 +181,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

data/lib/shrine/storage/linter.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require "shrine"
 
 require "forwardable"
@@ -30,19 +28,32 @@ class Shrine
         new(*args).call
       end
 
-      def initialize(storage, action: :error)
-        @storage = storage
-        @action  = action
+      def initialize(storage, action: :error, nonexisting: "nonexisting")
+        @storage     = storage
+        @action      = action
+        @nonexisting = nonexisting
       end
 
       def call(io_factory = default_io_factory)
-        storage.upload(io_factory.call, id = "foo".dup, {})
+        storage.upload(io_factory.call, id = "foo", shrine_metadata: { "foo" => "bar" })
 
         lint_open(id)
         lint_exists(id)
         lint_url(id)
         lint_delete(id)
 
+        if storage.respond_to?(:delete_prefixed)
+          storage.upload(io_factory.call, id1 = "a/a/a")
+          storage.upload(io_factory.call, id2 = "a/a/b")
+          storage.upload(io_factory.call, id3 = "a/aaa/a")
+
+          lint_delete_prefixed(prefix: "a/a/",
+                               expect_deleted: [id1, id2],
+                               expect_remaining: [id3])
+
+          storage.delete(id3)
+        end
+
         if storage.respond_to?(:clear!)
           storage.upload(io_factory.call, id = "quux".dup)
           lint_clear(id)
@@ -51,6 +62,8 @@ class Shrine
         if storage.respond_to?(:presign)
           lint_presign(id)
         end
+
+        true
       end
 
       def lint_open(id)
@@ -58,6 +71,14 @@ class Shrine
         error :open, "doesn't return a valid IO object" if !io?(opened)
         error :open, "returns an empty IO object" if opened.read.empty?
         opened.close
+
+        begin
+          storage.open(@nonexisting)
+          error :open, "should raise an exception on nonexisting file"
+        rescue Shrine::FileNotFound
+        rescue => exception
+          error :open, "should raise Shrine::FileNotFound on nonexisting file"
+        end
       end
 
       def lint_exists(id)
@@ -86,12 +107,26 @@ class Shrine
       end
 
       def lint_presign(id)
-        data = storage.presign(id, {})
+        data = storage.presign(id)
         error :presign, "result should be a Hash" unless data.respond_to?(:to_h)
         error :presign, "result should include :method key" unless data.to_h.key?(:method)
         error :presign, "result should include :url key" unless data.to_h.key?(:url)
       end
 
+      def lint_delete_prefixed(prefix:, expect_deleted:, expect_remaining:)
+        storage.delete_prefixed(prefix)
+
+        expect_deleted.each do |key|
+          next unless storage.exists?(key)
+          error :delete_prefixed, "#{key} still #exists? after #clear_prefix('a/a/')"
+        end
+
+        expect_remaining.each do |key|
+          next if storage.exists?(key)
+          error :delete_prefixed, "#{key} doesn't #exists? but should after #clear_prefix('a/a/')"
+        end
+      end
+
       private
 
       attr_reader :storage

data/lib/shrine/storage/memory.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "shrine"
+require "stringio"
+
+class Shrine
+  module Storage
+    class Memory
+      attr_reader :store
+
+      def initialize(store = {})
+        @store = store
+      end
+
+      def upload(io, id, **)
+        store[id] = io.read
+      end
+
+      def open(id, **)
+        io = StringIO.new(store.fetch(id))
+        io.set_encoding(io.string.encoding) # Ruby 2.7.0 – https://bugs.ruby-lang.org/issues/16497
+        io
+      rescue KeyError
+        raise Shrine::FileNotFound, "file #{id.inspect} not found on storage"
+      end
+
+      def exists?(id)
+        store.key?(id)
+      end
+
+      def url(id, *)
+        "memory://#{id}"
+      end
+
+      def delete(id)
+        store.delete(id)
+      end
+
+      def delete_prefixed(delete_prefix)
+        delete_prefix = delete_prefix.chomp("/") + "/"
+        store.delete_if { |key, _value| key.start_with?(delete_prefix) }
+      end
+
+      def clear!
+        store.clear
+      end
+    end
+  end
+end