shrine 1.3.0 → 1.4.0

data/lib/shrine/plugins/delete_uploaded.rb

@@ -1,40 +1,3 @@
-class Shrine
-  module Plugins
-    # The delete_uploaded plugin will automatically delete files after they
-    # have been uploaded. This is especially useful when doing processing, to
-    # ensure that temporary files have been deleted after upload. One exception
-    # are `Shrine::UploadedFile` files, they won't get deleted for stability
-    # reasons.
-    #
-    #     plugin :delete_uploaded
-    #
-    # By default this behaviour will be applied to all storages, but you can
-    # limit this only to specified storages:
-    #
-    #     plugin :delete_uploaded, storages: [:store]
-    module DeleteUploaded
-      def self.configure(uploader, storages: :all)
-        uploader.opts[:delete_uploaded_storages] = storages
-      end
-
-      module InstanceMethods
-        private
-
-        # Deletes the uploaded file unless it's an UploadedFile.
-        def copy(io, context)
-          super
-          if io.respond_to?(:delete) && !io.is_a?(UploadedFile)
-            io.delete if delete_uploaded?(io)
-          end
-        end
-
-        def delete_uploaded?(io)
-          opts[:delete_uploaded_storages] == :all ||
-          opts[:delete_uploaded_storages].include?(storage_key)
-        end
-      end
-    end
-
-    register_plugin(:delete_uploaded, DeleteUploaded)
-  end
-end
+warn "The delete_uploaded Shrine plugin has been renamed to \"delete_raw\". Loading the plugin through \"delete_uploaded\" will not work in Shrine 2."
+require "shrine/plugins/delete_raw"
+Shrine::Plugins.register_plugin(:delete_uploaded, Shrine::Plugins::DeleteRaw)

data/lib/shrine/plugins/determine_mime_type.rb

@@ -5,6 +5,11 @@ class Shrine
     #
     #     plugin :determine_mime_type
     #
+    # By default the UNIX [file] utility is used to determine the MIME type, but
+    # you can change it:
+    #
+    #     plugin :determine_mime_type, analyzer: :filemagic
+    #
     # The plugin accepts the following analyzers:
     #
     # :file
@@ -27,19 +32,10 @@ class Shrine
     #   *extension*. Note that unlike other solutions, this analyzer is not
     #   guaranteed to return the actual MIME type of the file.
     #
-    # By default the UNIX [file] utility is used to detrmine the MIME type, but
-    # you can change it:
-    #
-    #     plugin :determine_mime_type, analyzer: :filemagic
-    #
     # If none of these quite suit your needs, you can use a custom analyzer:
     #
     #     plugin :determine_mime_type, analyzer: ->(io) do
-    #       if io.path.end_with?(".odt")
-    #         "application/vnd.oasis.opendocument.text"
-    #       else
-    #         MimeMagic.by_magic(io).type
-    #       end
+    #       # returns the extracted MIME type
     #     end
     #
     # [file]: http://linux.die.net/man/1/file
@@ -77,13 +73,17 @@ class Shrine
         def extract_mime_type(io)
           analyzer = opts[:mime_type_analyzer]
 
-          if io.respond_to?(:mime_type)
+          mime_type = if io.respond_to?(:mime_type)
             io.mime_type
           elsif analyzer.is_a?(Symbol)
             send(:"_extract_mime_type_with_#{analyzer}", io)
           else
             analyzer.call(io)
           end
+
+          io.rewind
+
+          mime_type
         end
 
         private
@@ -98,7 +98,6 @@ class Shrine
             mime_type, _ = Open3.capture2(*cmd, io.path)
           else
             mime_type, _ = Open3.capture2(*cmd, "-", stdin_data: io.read(MAGIC_NUMBER), binmode: true)
-            io.rewind
           end
 
           mime_type.strip unless mime_type.empty?
@@ -107,16 +106,12 @@ class Shrine
         # Uses the ruby-filemagic gem to magically extract the MIME type.
         def _extract_mime_type_with_filemagic(io)
           filemagic = FileMagic.new(FileMagic::MAGIC_MIME_TYPE)
-          data = io.read(MAGIC_NUMBER)
-          io.rewind
-          filemagic.buffer(data)
+          filemagic.buffer(io.read(MAGIC_NUMBER))
         end
 
         # Uses the mimemagic gem to extract the MIME type.
         def _extract_mime_type_with_mimemagic(io)
-          result = MimeMagic.by_magic(io).type
-          io.rewind
-          result
+          MimeMagic.by_magic(io).type
         end
 
         # Uses the mime-types gem to determine MIME type from file extension.

data/lib/shrine/plugins/direct_upload.rb

@@ -18,10 +18,10 @@ class Shrine
     #
     # You should always mount a new endpoint for each uploader that you want to
     # enable direct uploads for. This now gives your Ruby application a `POST
-    # /attachments/images/:storage/:name` route, which accepts a "file" query
+    # /attachments/images/:storage/upload` route, which accepts a "file" query
     # parameter, and returns the uploaded file in JSON format:
     #
-    #     # POST /attachments/images/cache/avatar (file upload)
+    #     # POST /attachments/images/cache/upload (file upload)
     #     {
     #       "id": "43kewit94.jpg",
     #       "storage": "cache",
@@ -50,8 +50,9 @@ class Shrine
     # ## Presigning
     #
     # An alternative to the direct endpoint is uploading directly to the
-    # underlying storage (S3). These uploads usually require extra information
-    # from the server, you can enable that route by passing `presign: true`:
+    # underlying storage (currently only supported by Amazon S3). These uploads
+    # usually require extra information from the server, you can enable that
+    # route by passing `presign: true`:
     #
     #     plugin :direct_upload, presign: true
     #
@@ -78,24 +79,38 @@ class Shrine
     #
     #     GET /cache/presign?extension=.png
     #
+    # You can change how the key is generated with `:presign_location`:
+    #
+    #     plugin :direct_upload, presign: true, presign_location: ->(request) { "${filename}" }
+    #
     # If you want additional options to be passed to Storage::S3#presign, you
-    # can pass a block to `:presign`, and it will yield Roda's request object:
+    # can pass `:presign_options` with a hash or a block (which gets yielded
+    # Roda's request object):
     #
-    #     plugin :direct_upload, presign: ->(request) do
-    #       {
-    #         content_length_range: 0..(5*1024*1024), # limit the filesize to 5 MB
-    #         content_type: request.params["content_type"], # use "content_type" query parameter
-    #       }
+    #     plugin :direct_upload, presign: true, presign_options: {acl: "public-read"}
+    #
+    #     plugin :direct_upload, presign: true, presign_options: ->(request) do
+    #       options = {}
+    #       options[:content_length_range] = 0..(5*1024*1024)       # limit the filesize to 5 MB
+    #       options[:content_type] = request.params["content_type"] # use "content_type" query parameter
+    #       options
     #     end
     #
     # See the [Direct Uploads to S3] guide for further instructions on how to
-    # hook this up in a form.
+    # hook the presigned uploads to a form.
+    #
+    # ### Testing presigns
+    #
+    # If you want to test presigned uploads, but don't want to pay the
+    # performance cost of using Amazon S3 storage in tests, you can simply swap
+    # out S3 with a storage like FileSystem. The presigns will still get
+    # generated, but will simply point to this endpoint's upload route.
     #
     # ## Allowed storages
     #
     # While Shrine only accepts cached attachments on form submits (for security
     # reasons), you can use this endpoint to upload files to any storage, just
-    # add it do allowed storages:
+    # add it to allowed storages:
     #
     #     plugin :direct_upload, allowed_storages: [:cache, :store]
     #
@@ -141,9 +156,17 @@ class Shrine
         uploader.plugin :rack_file
       end
 
-      def self.configure(uploader, allowed_storages: [:cache], presign: nil, max_size: nil)
+      def self.configure(uploader, allowed_storages: [:cache], presign: nil, presign_options: {}, presign_location: nil, max_size: nil)
+        if presign.respond_to?(:call)
+          warn "Passing a block to :presign in direct_upload plugin is deprecated and will be removed in Shrine 2. Use :presign_options instead."
+          presign_options = presign
+          presign = true
+        end
+
         uploader.opts[:direct_upload_allowed_storages] = allowed_storages
         uploader.opts[:direct_upload_presign] = presign
+        uploader.opts[:direct_upload_presign_options] = presign_options
+        uploader.opts[:direct_upload_presign_location] = presign_location
         uploader.opts[:direct_upload_max_size] = max_size
 
         uploader.assign_upload_endpoint(App) unless uploader.const_defined?(:UploadEndpoint)
@@ -165,7 +188,7 @@ class Shrine
 
         # Returns the Roda direct upload endpoint.
         def direct_endpoint
-          warn "#{self}.direct_endpoint is deprecated and will be removed in Shrine 2, you should use #{self}::UploadEndpoint instead."
+          warn "Shrine.direct_endpoint is deprecated and will be removed in Shrine 2, you should use Shrine::UploadEndpoint instead."
           self::UploadEndpoint
         end
       end
@@ -175,36 +198,109 @@ class Shrine
       # with the file upload and returns the uploaded file as JSON.
       class App < Roda
         plugin :default_headers, "Content-Type"=>"application/json"
+        plugin :json_parser
 
         route do |r|
           r.on ":storage" do |storage_key|
-            allow_storage!(storage_key)
-            @uploader = shrine_class.new(storage_key.to_sym)
+            @uploader = get_uploader(storage_key)
 
-            r.post ":name" do |name|
+            r.post ["upload", ":name"] do |name|
               file = get_file
-              context = {name: name, phase: :cache}
+              context = get_context(name)
 
-              json @uploader.upload(file, context)
-            end unless presign
+              uploaded_file = upload(file, context)
+
+              json uploaded_file
+            end unless presign? && presign_storage?
 
             r.get "presign" do
-              location = SecureRandom.hex(30) + request.params["extension"].to_s
-              options = presign.call(request) if presign.respond_to?(:call)
+              location = get_presign_location
+              options = get_presign_options
 
-              signature = @uploader.storage.presign(location, options || {})
+              presign_data = generate_presign(location, options)
 
-              json Hash[url: signature.url, fields: signature.fields]
-            end if presign
+              json presign_data
+            end if presign?
           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 = {phase: :cache}
+
+          if name != "upload"
+            warn "The \"POST /:storage/:name\" route of the direct_upload Shrine plugin is deprecated, and it will be removed in Shrine 3. Use \"POST /:storage/upload\" instead."
+            context[:name] = name
+          end
+
+          if presign? && !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
+            SecureRandom.hex(30) + request.params["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)
-          if !allowed_storages.map(&:to_s).include?(storage)
-            error! 403, "Storage #{storage.inspect} 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
 
@@ -253,10 +349,18 @@ class Shrine
           shrine_class.opts[:direct_upload_allowed_storages]
         end
 
-        def presign
+        def presign?
           shrine_class.opts[:direct_upload_presign]
         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

data/lib/shrine/plugins/download_endpoint.rb

@@ -97,8 +97,7 @@ class Shrine
 
         route do |r|
           r.on ":storage" do |storage_key|
-            allow_storage!(storage_key)
-            @storage = shrine_class.find_storage(storage_key)
+            @storage = get_storage(storage_key)
 
             r.get /(.*)/ do |id|
               filename = request.path.split("/").last
@@ -107,14 +106,13 @@ class Shrine
               response["Content-Disposition"] = "#{disposition}; filename=#{filename.inspect}"
               response["Content-Type"] = Rack::Mime.mime_type(extname)
 
+              chunks = get_stream(id)
+              _, content_length = chunks.peek
+              response['Content-Length'] = content_length.to_s if content_length
+
               stream do |out|
-                if @storage.respond_to?(:stream)
-                  @storage.stream(id) { |chunk| out << chunk }
-                else
-                  io, buffer = @storage.open(id), ""
-                  out << io.read(16384, buffer) until io.eof?
-                  io.close
-                  io.delete if io.class.name == "Tempfile"
+                chunks.each do |chunk|
+                  out << chunk
                 end
               end
             end
@@ -123,10 +121,31 @@ class Shrine
 
         private
 
+        attr_reader :storage
+
+        def get_storage(storage_key)
+          allow_storage!(storage_key)
+          shrine_class.find_storage(storage_key)
+        end
+
+        def get_stream(id)
+          if storage.respond_to?(:stream)
+            storage.enum_for(:stream, id)
+          else
+            Enumerator.new do |y|
+              io = storage.open(id)
+              buffer = ""
+              y.yield(io.read(16*1024, buffer), io.size) until io.eof?
+              io.close
+              io.delete if io.class.name == "Tempfile"
+            end
+          end
+        end
+
         # Halts the request if storage is not allowed.
-        def allow_storage!(storage)
-          if !allowed_storages.map(&:to_s).include?(storage)
-            error! 403, "Storage #{storage.inspect} 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
 

data/lib/shrine/plugins/hooks.rb

@@ -22,24 +22,21 @@ class Shrine
     #
     # Shrine calls hooks in the following order when uploading a file:
     #
+    # * `before_upload`
     # * `around_upload`
-    #     * `before_upload`
+    #     * `before_process`
     #     * `around_process`
-    #         * `before_process`
-    #         * PROCESS
-    #         * `after_process`
+    #     * `after_process`
+    #     * `before_store`
     #     * `around_store`
-    #         * `before_store`
-    #         * STORE
-    #         * `after_store`
-    #     * `after_upload`
+    #     * `after_store`
+    # * `after_upload`
     #
     # Shrine calls hooks in the following order when deleting a file:
     #
+    # * `before_delete`
     # * `around_delete`
-    #     * `before_delete`
-    #     * DELETE
-    #     * `after_delete`
+    # * `after_delete`
     #
     # By default every `around_*` hook returns the result of the corresponding
     # operation:
@@ -51,39 +48,18 @@ class Shrine
     #         result # it's good to always return the result for consistent behaviour
     #       end
     #     end
-    #
-    # It may be useful to know that you can realize some form of communication
-    # between the hooks; whatever you save to the `context` hash will be
-    # forwarded further down:
-    #
-    #     class ImageUploader < Shrine
-    #       def before_process(io, context)
-    #         context[:_foo] = "bar"
-    #         super
-    #       end
-    #
-    #       def before_store(io, context)
-    #         context[:_foo] #=> "bar"
-    #         super
-    #       end
-    #     end
-    #
-    # In that case you should always somehow mark this key as private (for
-    # example with an underscore) so that it doesn't clash with any
-    # existing keys.
     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)
-          before_upload(*args)
-          result = yield
-          after_upload(*args)
-          result
+          yield
         end
 
         def before_upload(*)
@@ -95,16 +71,15 @@ class Shrine
 
         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)
-          before_process(*args)
-          result = yield
-          after_process(*args)
-          result
+          yield
         end
 
         def before_process(*)
@@ -116,15 +91,14 @@ class Shrine
 
         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)
-          before_store(*args)
-          result = yield
-          after_store(*args)
-          result
+          yield
         end
 
         def before_store(*)
@@ -136,14 +110,14 @@ class Shrine
 
         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)
-          before_delete(*args)
-          result = yield
-          after_delete(*args)
+          yield
         end
 
         def before_delete(*)

data/lib/shrine/plugins/keep_files.rb

@@ -26,10 +26,13 @@ class Shrine
         uploader.opts[:keep_files] << :replaced if replaced
       end
 
-      module InstanceMethods
-        # We hook to the generic deleting, and check the appropriate phases.
-        def delete(io, context = {})
-          super unless opts[:keep_files].include?(context[:phase])
+      module AttacherMethods
+        def replace
+          super unless shrine_class.opts[:keep_files].include?(:replaced)
+        end
+
+        def destroy
+          super unless shrine_class.opts[:keep_files].include?(:destroyed)
         end
       end
     end

data/lib/shrine/plugins/logging.rb

@@ -12,8 +12,8 @@ class Shrine
     # going on, or you simply want to have it logged for future debugging.
     # By default the logging output looks something like this:
     #
-    #     2015-10-09T20:06:06.676Z #25602: UPLOAD[direct] ImageUploader[:avatar] User[29543] 1 file (0.1s)
-    #     2015-10-09T20:06:06.854Z #25602: PROCESS[promote]: ImageUploader[:avatar] User[29543] 3 files (0.22s)
+    #     2015-10-09T20:06:06.676Z #25602: STORE[cache] ImageUploader[:avatar] User[29543] 1 file (0.1s)
+    #     2015-10-09T20:06:06.854Z #25602: PROCESS[store]: ImageUploader[:avatar] User[29543] 1-3 files (0.22s)
     #     2015-10-09T20:06:07.133Z #25602: DELETE[destroyed]: ImageUploader[:avatar] User[29543] 3 files (0.07s)
     #
     # The plugin accepts the following options:
@@ -36,16 +36,20 @@ class Shrine
     # grep. If this is important to you, you can switch to another format:
     #
     #     plugin :logging, format: :json
-    #     # {"action":"upload","phase":"direct","uploader":"ImageUploader","attachment":"avatar",...}
+    #     # {"action":"upload","phase":"cache","uploader":"ImageUploader","attachment":"avatar",...}
     #
     #     plugin :logging, format: :heroku
-    #     # action=upload phase=direct uploader=ImageUploader attachment=avatar record_class=User ...
+    #     # action=upload phase=cache uploader=ImageUploader attachment=avatar record_class=User ...
     #
     # Logging is by default disabled in tests, but you can enable it by setting
     # `Shrine.logger.level = Logger::INFO`.
     module Logging
+      def self.load_dependencies(uploader, *)
+        uploader.plugin :hooks
+      end
+
       def self.configure(uploader, logger: nil, stream: $stdout, format: :human)
-        uploader.logger = logger if logger
+        uploader.opts[:logging_logger] = logger
         uploader.opts[:logging_stream] = stream
         uploader.opts[:logging_format] = format
       end
@@ -57,7 +61,7 @@ class Shrine
 
         # Initializes a new logger if it hasn't been initialized.
         def logger
-          @logger ||= (
+          @logger ||= opts[:logging_logger] || (
             logger = Logger.new(opts[:logging_stream])
             logger.level = Logger::INFO
             logger.level = Logger::WARN if ENV["RACK_ENV"] == "test"
@@ -78,22 +82,22 @@ class Shrine
       end
 
       module InstanceMethods
-        def store(io, context = {})
+        def around_process(io, context)
+          log("process", io, context) { super }
+        end
+
+        def around_store(io, context)
           log("store", io, context) { super }
         end
 
-        def delete(io, context = {})
+        def around_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, io, context)
+        def log(action, input, context)
           result, duration = benchmark { yield }
 
           _log(
@@ -103,7 +107,7 @@ class Shrine
             attachment:   context[:name],
             record_class: (context[:record].class if context[:record]),
             record_id:    (context[:record].id if context[:record].respond_to?(:id)),
-            files:        count(io),
+            files:        (action == "process" ? [count(input), count(result)] : count(result)),
             duration:     ("%.2f" % duration).to_f,
           ) unless result.nil?
 
@@ -124,16 +128,18 @@ class Shrine
           components.last << "[:#{data[:attachment]}]" if data[:attachment]
           components << "#{data[:record_class]}" if data[:record_class]
           components.last << "[#{data[:record_id]}]" if data[:record_id]
-          components << (data[:files] > 1 ? "#{data[:files]} files" : "#{data[:files]} file")
+          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("-")
           data.to_json
         end
 
         def _log_message_heroku(data)
+          data[:files] = Array(data[:files]).join("-")
           data.map { |key, value| "#{key}=#{value}" }.join(" ")
         end