shrine 2.19.4 → 3.4.0

data/lib/shrine/plugins/copy.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-Shrine.deprecation("The copy plugin is deprecated and will be removed in Shrine 3.")
-
-class Shrine
-  module Plugins
-    # Documentation lives in [doc/plugins/copy.md] on GitHub.
-    #
-    # [doc/plugins/copy.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/copy.md
-    module Copy
-      module AttachmentMethods
-        def initialize(*)
-          super
-
-          name = attachment_name
-
-          define_method :initialize_copy do |record|
-            super(record)
-            instance_variable_set(:"@#{name}_attacher", nil) # reload the attacher
-            attacher = send(:"#{name}_attacher")
-            attacher.send(:write, nil) # remove original attachment
-            attacher.copy(record.public_send(:"#{name}_attacher"))
-          end
-
-          # Fix for JRuby
-          private :initialize_copy
-        end
-      end
-
-      module AttacherMethods
-        def copy(attacher)
-          options = {action: :copy, move: false}
-
-          copied_attachment = if attacher.cached?
-                                cache!(attacher.get, **options)
-                              elsif attacher.stored?
-                                store!(attacher.get, **options)
-                              else
-                                nil
-                              end
-
-          @old = get
-          _set(copied_attachment)
-        end
-      end
-    end
-
-    register_plugin(:copy, Copy)
-  end
-end

data/lib/shrine/plugins/delete_promoted.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-class Shrine
-  module Plugins
-    # Documentation lives in [doc/plugins/delete_promoted.md] on GitHub.
-    #
-    # [doc/plugins/delete_promoted.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/delete_promoted.md
-    module DeletePromoted
-      module AttacherMethods
-        def promote(uploaded_file = get, **options)
-          result = super
-          _delete(uploaded_file, action: :promote)
-          result
-        end
-      end
-    end
-
-    register_plugin(:delete_promoted, DeletePromoted)
-  end
-end

data/lib/shrine/plugins/direct_upload.rb

@@ -1,217 +0,0 @@
-# frozen_string_literal: true
-
-Shrine.deprecation("The direct_upload plugin has been deprecated in favor of upload_endpoint and presign_endpoint plugins. The direct_upload plugin will be removed in Shrine 3.")
-
-require "roda"
-require "json"
-
-class Shrine
-  module Plugins
-    # Documentation lives in [doc/plugins/direct_upload.md] on GitHub.
-    #
-    # [doc/plugins/direct_upload.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/direct_upload.md
-    module DirectUpload
-      def self.load_dependencies(uploader, *)
-        uploader.plugin :rack_file
-      end
-
-      def self.configure(uploader, opts = {})
-        uploader.opts[:direct_upload_allowed_storages] = opts.fetch(:allowed_storages, uploader.opts.fetch(:direct_upload_allowed_storages, [:cache]))
-        uploader.opts[:direct_upload_presign_options] = opts.fetch(:presign_options, uploader.opts.fetch(:direct_upload_presign_options, {}))
-        uploader.opts[:direct_upload_presign_location] = opts.fetch(:presign_location, uploader.opts[:direct_upload_presign_location])
-        uploader.opts[:direct_upload_max_size] = opts.fetch(:max_size, uploader.opts[:direct_upload_max_size])
-
-        uploader.assign_upload_endpoint(App) unless uploader.const_defined?(:UploadEndpoint)
-      end
-
-      module ClassMethods
-        # Assigns the subclass a copy of the upload endpoint class.
-        def inherited(subclass)
-          super
-          subclass.assign_upload_endpoint(self::UploadEndpoint)
-        end
-
-        # Assigns the subclassed endpoint as the `UploadEndpoint` constant.
-        def assign_upload_endpoint(klass)
-          endpoint_class = Class.new(klass)
-          endpoint_class.opts[:shrine_class] = self
-          const_set(:UploadEndpoint, endpoint_class)
-        end
-      end
-
-      # Routes incoming requests. It first asserts that the storage is existent
-      # and allowed, then the filesize isn't too large. Afterwards it proceeds
-      # with the file upload and returns the uploaded file as JSON.
-      class App < Roda
-        plugin :default_headers, "Content-Type"=>"application/json"
-        plugin :placeholder_string_matchers if Gem::Version.new(Roda::RodaVersion) >= Gem::Version.new("3.0.0")
-
-        route do |r|
-          r.on ":storage" do |storage_key|
-            @uploader = get_uploader(storage_key)
-
-            r.post ["upload", ":name"] do |name|
-              file = get_file
-              context = get_context(name)
-
-              uploaded_file = upload(file, context)
-
-              json uploaded_file
-            end
-
-            r.get "presign" do
-              location = get_presign_location
-              options = get_presign_options
-
-              presign_data = generate_presign(location, options)
-              response.headers["Cache-Control"] = "no-store"
-
-              json presign_data
-            end
-          end
-        end
-
-        private
-
-        attr_reader :uploader
-
-        # Instantiates the uploader, checking first if the storage is allowed.
-        def get_uploader(storage_key)
-          allow_storage!(storage_key)
-          shrine_class.new(storage_key.to_sym)
-        end
-
-        # Retrieves the context for the upload.
-        def get_context(name)
-          context = {action: :cache, phase: :cache}
-
-          if name != "upload"
-            Shrine.deprecation("The \"POST /:storage/:name\" route of the direct_upload plugin is deprecated, and it will be removed in Shrine 3. Use \"POST /:storage/upload\" instead.")
-            context[:name] = name
-          end
-
-          unless presign_storage?
-            context[:location] = request.params["key"]
-          end
-
-          context
-        end
-
-        # Uploads the file to the requested storage.
-        def upload(file, context)
-          uploader.upload(file, context)
-        end
-
-        # Generates a unique location, or calls `:presign_location`.
-        def get_presign_location
-          if presign_location
-            presign_location.call(request)
-          else
-            extension = request.params["extension"]
-            extension.prepend(".") if extension && !extension.start_with?(".")
-            uploader.send(:generate_uid, nil) + extension.to_s
-          end
-        end
-
-        # Returns dynamic options for generating the presign.
-        def get_presign_options
-          options = presign_options
-          options = options.call(request) if options.respond_to?(:call)
-          options || {}
-        end
-
-        # Generates the presign hash for the request.
-        def generate_presign(location, options)
-          if presign_storage?
-            generate_real_presign(location, options)
-          else
-            generate_fake_presign(location, options)
-          end
-        end
-
-        # Generates a presign by calling the storage.
-        def generate_real_presign(location, options)
-          signature = uploader.storage.presign(location, options)
-          {url: signature.url, fields: signature.fields}
-        end
-
-        # Generates a presign that points to the direct upload endpoint.
-        def generate_fake_presign(location, options)
-          url = request.url.sub(/presign[^\/]*$/, "upload")
-          {url: url, fields: {key: location}}
-        end
-
-        # Returns true if the storage supports presigns.
-        def presign_storage?
-          uploader.storage.respond_to?(:presign)
-        end
-
-        # Halts the request if storage is not allowed.
-        def allow_storage!(storage_key)
-          if !allowed_storages.map(&:to_s).include?(storage_key)
-            error! 403, "Storage #{storage_key.inspect} is not allowed."
-          end
-        end
-
-        # Returns the Rack file wrapped in an IO-like object. If "file" is
-        # missing or is too big, the request is halted.
-        def get_file
-          file = require_param!("file")
-          error! 400, "The \"file\" query parameter is not a file." if !(file.is_a?(Hash) && file.key?(:tempfile))
-          check_filesize!(file[:tempfile]) if max_size
-
-          RackFile::UploadedFile.new(file)
-        end
-
-        # If the file is too big, deletes the file and halts the request.
-        def check_filesize!(file)
-          if file.size > max_size
-            file.delete
-            megabytes = max_size.to_f / 1024 / 1024
-            error! 413, "The file is too big (maximum size is #{megabytes} MB)."
-          end
-        end
-
-        # Loudly requires the param.
-        def require_param!(name)
-          request.params.fetch(name)
-        rescue KeyError
-          error! 400, "Missing query parameter: #{name.inspect}"
-        end
-
-        # Halts the request with the error message.
-        def error!(status, message)
-          response.status = status
-          response.write({error: message}.to_json)
-          request.halt
-        end
-
-        def json(object)
-          object.to_json
-        end
-
-        def shrine_class
-          opts[:shrine_class]
-        end
-
-        def allowed_storages
-          shrine_class.opts[:direct_upload_allowed_storages]
-        end
-
-        def presign_options
-          shrine_class.opts[:direct_upload_presign_options]
-        end
-
-        def presign_location
-          shrine_class.opts[:direct_upload_presign_location]
-        end
-
-        def max_size
-          shrine_class.opts[:direct_upload_max_size]
-        end
-      end
-    end
-
-    register_plugin(:direct_upload, DirectUpload)
-  end
-end

data/lib/shrine/plugins/hooks.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-class Shrine
-  module Plugins
-    # Documentation lives in [doc/plugins/hooks.md] on GitHub.
-    #
-    # [doc/plugins/hooks.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/hooks.md
-    module Hooks
-      module InstanceMethods
-        def upload(io, context = {})
-          result = nil
-          before_upload(io, context)
-          around_upload(io, context) { result = super }
-          after_upload(io, context)
-          result
-        end
-
-        def around_upload(*args)
-          yield
-        end
-
-        def before_upload(*)
-        end
-
-        def after_upload(*)
-        end
-
-
-        def processed(io, context)
-          result = nil
-          before_process(io, context)
-          around_process(io, context) { result = super }
-          after_process(io, context)
-          result
-        end
-        private :processed
-
-        def around_process(*args)
-          yield
-        end
-
-        def before_process(*)
-        end
-
-        def after_process(*)
-        end
-
-
-        def store(io, context = {})
-          result = nil
-          before_store(io, context)
-          around_store(io, context) { result = super }
-          after_store(io, context)
-          result
-        end
-
-        def around_store(*args)
-          yield
-        end
-
-        def before_store(*)
-        end
-
-        def after_store(*)
-        end
-
-
-        def delete(io, context = {})
-          result = nil
-          before_delete(io, context)
-          around_delete(io, context) { result = super }
-          after_delete(io, context)
-          result
-        end
-
-        def around_delete(*args)
-          yield
-        end
-
-        def before_delete(*)
-        end
-
-        def after_delete(*)
-        end
-      end
-    end
-
-    register_plugin(:hooks, Hooks)
-  end
-end

data/lib/shrine/plugins/logging.rb

@@ -1,142 +0,0 @@
-# frozen_string_literal: true
-
-Shrine.deprecation("The logging plugin has been deprecated in favor of instrumentation plugin. The logging plugin will be removed in Shrine 3.")
-
-require "logger"
-require "json"
-require "time"
-
-class Shrine
-  module Plugins
-    # Documentation lives in [doc/plugins/logging.md] on GitHub.
-    #
-    # [doc/plugins/logging.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/logging.md
-    module Logging
-      def self.load_dependencies(uploader, *)
-        uploader.plugin :hooks
-      end
-
-      def self.configure(uploader, opts = {})
-        uploader.opts[:logging_stream] = opts.fetch(:stream, uploader.opts.fetch(:logging_stream, $stdout))
-        uploader.opts[:logging_logger] = opts.fetch(:logger, uploader.opts.fetch(:logging_logger, uploader.create_logger))
-        uploader.opts[:logging_format] = opts.fetch(:format, uploader.opts.fetch(:logging_format, :human))
-
-        Shrine.deprecation("The :heroku logging format has been renamed to :logfmt. Using :heroku name will stop being supported in Shrine 3.") if uploader.opts[:logging_format] == :heroku
-      end
-
-      module ClassMethods
-        def logger=(logger)
-          @logger = logger
-        end
-
-        def logger
-          @logger ||= opts[:logging_logger]
-        end
-
-        def create_logger
-          logger = Logger.new(opts[:logging_stream])
-          logger.level = Logger::INFO
-          logger.level = Logger::WARN if ENV["RACK_ENV"] == "test"
-          logger.formatter = pretty_formatter
-          logger
-        end
-
-        # It makes logging preamble simpler than the default logger. Also, it
-        # doesn't output timestamps if on Heroku.
-        def pretty_formatter
-          proc do |severity, time, program_name, message|
-            output = "#{Process.pid}: #{message}\n".dup
-            output.prepend "#{time.utc.iso8601(3)} " unless ENV["DYNO"]
-            output
-          end
-        end
-      end
-
-      module InstanceMethods
-        def store(io, context = {})
-          log("store", io, context) { super }
-        end
-
-        def delete(io, context = {})
-          log("delete", io, context) { super }
-        end
-
-        private
-
-        def processed(io, context = {})
-          log("process", io, context) { super }
-        end
-
-        # Collects the data and sends it for logging.
-        def log(action, input, context)
-          result, duration = benchmark { yield }
-
-          _log(
-            action:       action,
-            phase:        context[:action],
-            uploader:     self.class.to_s,
-            attachment:   context[:name],
-            record_class: (context[:record].class.to_s if context[:record]),
-            record_id:    (context[:record].id if context[:record].respond_to?(:id)),
-            files:        (action == "process" ? [count(input), count(result)] : count(result)),
-            duration:     ("%.2f" % duration).to_f,
-          ) unless result.nil?
-
-          result
-        end
-
-        # Determines format of logging and calls appropriate method.
-        def _log(data)
-          message = send("_log_message_#{opts[:logging_format]}", data)
-          self.class.logger.info(message)
-        end
-
-        def _log_message_human(data)
-          components = []
-          components << "#{data[:action].upcase}"
-          components[-1] += "[#{data[:phase]}]" if data[:phase]
-          components << "#{data[:uploader]}"
-          components[-1] += "[:#{data[:attachment]}]" if data[:attachment]
-          components << "#{data[:record_class]}" if data[:record_class]
-          components[-1] += "[#{data[:record_id]}]" if data[:record_id]
-          components << "#{Array(data[:files]).join("-")} #{"file#{"s" if Array(data[:files]).any?{|n| n > 1}}"}"
-          components << "(#{data[:duration]}s)"
-          components.join(" ")
-        end
-
-        def _log_message_json(data)
-          data[:files] = Array(data[:files]).join("-")
-          JSON.generate(data)
-        end
-
-        def _log_message_logfmt(data)
-          data[:files] = Array(data[:files]).join("-")
-          data.map { |key, value| "#{key}=#{value}" }.join(" ")
-        end
-        alias _log_message_heroku _log_message_logfmt # deprecated alias
-
-        # We may have one file, a hash of versions, or an array of files or
-        # hashes.
-        def count(object)
-          case object
-          when Hash
-            object.count
-          when Array
-            object.inject(0) { |sum, o| sum += count(o) }
-          else
-            1
-          end
-        end
-
-        def benchmark
-          start = Time.now
-          result = yield
-          finish = Time.now
-          [result, finish - start]
-        end
-      end
-    end
-
-    register_plugin(:logging, Logging)
-  end
-end

data/lib/shrine/plugins/migration_helpers.rb

@@ -1,70 +0,0 @@
-# frozen_string_literal: true
-
-Shrine.deprecation("The migration_helpers plugin is deprecated and will be removed in Shrine 3. Attacher#cached? and Attacher#stored? have been moved to base.")
-
-class Shrine
-  module Plugins
-    # Documentation lives in [doc/plugins/migration_helpers.md] on GitHub.
-    #
-    # [doc/plugins/migration_helpers.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/migration_helpers.md
-    module MigrationHelpers
-      def self.configure(uploader, delegate: false)
-        uploader.opts[:migration_helpers_delegate] = delegate
-      end
-
-      module AttachmentMethods
-        def initialize(name)
-          super
-
-          return if shrine_class.opts[:migration_helpers_delegate] == false
-
-          name = attachment_name
-
-          define_method :"update_#{name}" do |&block|
-            send(:"#{name}_attacher").update_stored(&block)
-          end
-
-          define_method :"#{name}_cache" do
-            send(:"#{name}_attacher").cache
-          end
-
-          define_method :"#{name}_store" do
-            send(:"#{name}_attacher").store
-          end
-
-          define_method :"#{name}_cached?" do
-            send(:"#{name}_attacher").cached?
-          end
-
-          define_method :"#{name}_stored?" do
-            send(:"#{name}_attacher").stored?
-          end
-        end
-      end
-
-      module AttacherMethods
-        # Updates the attachment with the result of the block. It will get
-        # called only if the attachment exists and is stored.
-        def update_stored(&block)
-          return if get.nil? || cache.uploaded?(get)
-          new_attachment = block.call(get)
-          swap(new_attachment)
-        end
-
-        # Returns true if the attachment is present and is uploaded by the
-        # temporary storage.
-        def cached?
-          get && cache.uploaded?(get)
-        end
-
-        # Returns true if the attachment is present and is uploaded by the
-        # permanent storage.
-        def stored?
-          get && store.uploaded?(get)
-        end
-      end
-    end
-
-    register_plugin(:migration_helpers, MigrationHelpers)
-  end
-end

data/lib/shrine/plugins/moving.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-Shrine.deprecation("The moving plugin has been deprecated in favor of the :move upload option for FileSystem storage. It will no longer be available in Shrine 3.")
-
-class Shrine
-  module Plugins
-    # Documentation lives in [doc/plugins/moving.md] on GitHub.
-    #
-    # [doc/plugins/moving.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/moving.md
-    module Moving
-      def self.configure(uploader, opts = {})
-        uploader.opts[:moving_storages] = opts.fetch(:storages, uploader.opts[:moving_storages])
-      end
-
-      module InstanceMethods
-        private
-
-        # Moves the file if storage supports it, otherwise defaults to copying.
-        def copy(io, context)
-          if move?(io, context)
-            move(io, context)
-          else
-            super
-          end
-        end
-
-        # Generates upload options and calls `#move` on the storage.
-        def move(io, context)
-          location = context[:location]
-          metadata = context[:metadata]
-          upload_options = context[:upload_options] || {}
-
-          storage.move(io, location, shrine_metadata: metadata, **upload_options)
-        end
-
-        # Returns true if file should be moved and is movable.
-        def move?(io, context)
-          return false if context[:move] == false
-          moving_storage? && movable?(io, context)
-        end
-
-        # Returns true if storage can move this file.
-        def movable?(io, context)
-          storage.respond_to?(:move) && storage.movable?(io, context[:location])
-        end
-
-        # Returns true if file should be moved.
-        def moving_storage?
-          opts[:moving_storages].nil? ||
-          opts[:moving_storages].include?(storage_key)
-        end
-      end
-    end
-
-    register_plugin(:moving, Moving)
-  end
-end

data/lib/shrine/plugins/multi_delete.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-Shrine.deprecation("The multi_delete plugin is deprecated and will be removed in Shrine 3.")
-
-class Shrine
-  module Plugins
-    # Documentation lives in [doc/plugins/multi_delete.md] on GitHub.
-    #
-    # [doc/plugins/multi_delete.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/multi_delete.md
-    module MultiDelete
-      module InstanceMethods
-        private
-
-        # Adds the ability to upload multiple files, leveraging the underlying
-        # storage's potential multi delete capability.
-        def _delete(uploaded_file, context)
-          if uploaded_file.is_a?(Array)
-            if storage.respond_to?(:multi_delete)
-              storage.multi_delete(uploaded_file.map(&:id))
-            else
-              uploaded_file.each { |file| _delete(file, context) }
-            end
-          else
-            super
-          end
-        end
-      end
-    end
-
-    register_plugin(:multi_delete, MultiDelete)
-  end
-end