shrine 2.8.0 → 2.9.0

data/lib/shrine/plugins/backup.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `backup` plugin allows you to automatically back up stored files to

data/lib/shrine/plugins/cached_attachment_data.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `cached_attachment_data` plugin adds the ability to retain the cached

data/lib/shrine/plugins/copy.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `copy` plugin allows copying attachment from one record to another.

data/lib/shrine/plugins/data_uri.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "base64"
 require "strscan"
 require "cgi"
@@ -32,6 +34,18 @@ class Shrine
     #     plugin :data_uri, error_message: "data URI was invalid"
     #     plugin :data_uri, error_message: ->(uri) { I18n.t("errors.data_uri_invalid") }
     #
+    # ## File extension
+    #
+    # A data URI doesn't convey any information about the file extension, so
+    # when attaching from a data URI, the uploaded file location will be
+    # missing an extension. If you want the upload location to always have an
+    # extension, you can load the `infer_extension` plugin to infer it from the
+    # MIME type.
+    #
+    #     plugin :infer_extension
+    #
+    # ## `Shrine.data_uri`
+    #
     # If you just want to parse the data URI and create an IO object from it,
     # you can do that with `Shrine.data_uri`. If the data URI cannot be parsed,
     # a `Shrine::Plugins::DataUri::ParseError` will be raised.
@@ -50,19 +64,11 @@ class Shrine
     #     io.size         #=> 11
     #     io.read         #=> "raw content"
     #
-    # The created IO object won't convey any file extension (because it doesn't
-    # have a filename), but you can generate a filename based on the content
-    # type of the data URI:
-    #
-    #     require "mime/types"
+    # ## `UploadedFile#data_uri` and `UploadedFile#base64`
     #
-    #     plugin :data_uri, filename: ->(content_type) do
-    #       extension = MIME::Types[content_type].first.preferred_extension
-    #       "data_uri.#{extension}"
-    #     end
-    #
-    # This plugin also adds a `UploadedFile#data_uri` method (and `#base64`),
-    # which returns a base64-encoded data URI of any UploadedFile:
+    # This plugin also adds UploadedFile#data_uri method, which returns a
+    # base64-encoded data URI of the file content, and UploadedFile#base64,
+    # which simply returns the file content base64-encoded.
     #
     #     uploaded_file.data_uri #=> "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA"
     #     uploaded_file.base64   #=> "iVBORw0KGgoAAAANSUhEUgAAAAUA"
@@ -81,6 +87,8 @@ class Shrine
       def self.configure(uploader, opts = {})
         uploader.opts[:data_uri_filename] = opts.fetch(:filename, uploader.opts[:data_uri_filename])
         uploader.opts[:data_uri_error_message] = opts.fetch(:error_message, uploader.opts[:data_uri_error_message])
+
+        Shrine.deprecation("The :filename option is deprecated for the data_uri plugin, and will be removed in Shrine 3. Use the infer_extension plugin instead.") if opts[:filename]
       end
 
       module ClassMethods

data/lib/shrine/plugins/default_storage.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `default_storage` plugin enables you to change which storages are going

data/lib/shrine/plugins/default_url.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `default_url` plugin allows setting the URL which will be returned when

data/lib/shrine/plugins/default_url_options.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `default_url_options` plugin allows you to specify URL options that

data/lib/shrine/plugins/delete_promoted.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `delete_promoted` plugin deletes files that have been promoted, after

data/lib/shrine/plugins/delete_raw.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `delete_raw` plugin will automatically delete raw files that have been

data/lib/shrine/plugins/determine_mime_type.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `determine_mime_type` plugin allows you to determine and store the
@@ -28,6 +30,13 @@ class Shrine
     #   Unlike ruby-filemagic, mimemagic is a pure-ruby solution, so it will
     #   work across all Ruby implementations.
     #
+    # :marcel
+    # : Uses the [marcel] gem to determine the MIME type from file contents.
+    #   Marcel is Basecamp's wrapper around mimemagic, it adds priority logic
+    #   (preferring magic over name when given both), some extra type
+    #   definitions, and common type subclasses (including Keynote, Pages,
+    #   etc).
+    #
     # :mime_types
     # : Uses the [mime-types] gem to determine the MIME type from the file
     #   extension. Note that unlike other solutions, this analyzer is not
@@ -49,7 +58,7 @@ class Shrine
     # correctly determine MIME type of .css, .js, .json, .csv, .xml, or similar
     # text-based files, you can combine `file` and `mime_types` analyzers:
     #
-    #     plugin :determine_mime_type, analyzer: ->(io, analyzers) do
+    #     plugin :determine_mime_type, analyzer: -> (io, analyzers) do
     #       mime_type = analyzers[:file].call(io)
     #       mime_type = analyzers[:mime_types].call(io) if mime_type == "text/plain"
     #       mime_type
@@ -69,6 +78,7 @@ class Shrine
     # [Windows equivalent]: http://gnuwin32.sourceforge.net/packages/file.htm
     # [ruby-filemagic]: https://github.com/blackwinter/ruby-filemagic
     # [mimemagic]: https://github.com/minad/mimemagic
+    # [marcel]: https://github.com/basecamp/marcel
     # [mime-types]: https://github.com/mime-types/ruby-mime-types
     # [mini_mime]: https://github.com/discourse/mini_mime
     module DetermineMimeType
@@ -125,7 +135,7 @@ class Shrine
       end
 
       class MimeTypeAnalyzer
-        SUPPORTED_TOOLS = [:file, :filemagic, :mimemagic, :mime_types, :mini_mime]
+        SUPPORTED_TOOLS = [:file, :filemagic, :mimemagic, :marcel, :mime_types, :mini_mime]
         MAGIC_NUMBER    = 256 * 1024
 
         def initialize(tool)
@@ -181,6 +191,12 @@ class Shrine
           mime.type if mime
         end
 
+        def extract_with_marcel(io)
+          require "marcel"
+
+          Marcel::MimeType.for(io)
+        end
+
         def extract_with_mime_types(io)
           require "mime/types"
 

data/lib/shrine/plugins/direct_upload.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "roda"
 require "json"
 
@@ -28,9 +30,9 @@ class Shrine
     #     end
     #
     # Now your application will get `POST /images/cache/upload` and `GET
-    # /images/cache/presign` routes. Whether you upload files to your app or to
-    # to a 3rd-party service, you'll probably want to use a JavaScript file
-    # upload library like [jQuery-File-Upload], [Dropzone] or [FineUploader].
+    # /images/cache/presign` routes. On the client side it is recommended to
+    # use [Uppy] for uploading files to the app or directly to the 3rd-party
+    # service.
     #
     # ## Uploads
     #
@@ -155,9 +157,7 @@ class Shrine
     # configuration.
     #
     # [Roda]: https://github.com/jeremyevans/roda
-    # [jQuery-File-Upload]: https://github.com/blueimp/jQuery-File-Upload
-    # [Dropzone]: https://github.com/enyo/dropzone
-    # [FineUploader]: https://github.com/FineUploader/fine-uploader
+    # [Uppy]: https://uppy.io
     # [Roda request]: http://roda.jeremyevans.net/rdoc/classes/Roda/RodaPlugins/Base/RequestMethods.html
     # [Direct Uploads to S3]: http://shrinerb.com/rdoc/files/doc/direct_s3_md.html
     module DirectUpload

data/lib/shrine/plugins/download_endpoint.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "roda"
 
 require "base64"

data/lib/shrine/plugins/dynamic_storage.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `dynamic_storage` plugin allows you to register a storage using a

data/lib/shrine/plugins/hooks.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `hooks` plugin allows you to trigger some code around

data/lib/shrine/plugins/included.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `included` plugin allows you to hook up to the `.included` hook of the

data/lib/shrine/plugins/infer_extension.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    # The `infer_extension` plugin allows deducing the appropriate file
+    # extension for the upload location based on the MIME type of the file.
+    # This is useful when using `data_uri` and `remote_url` plugins, where the
+    # file extension is not or might not be known.
+    #
+    #     plugin :infer_extension
+    #
+    # The upload location will gain the inferred extension only if couldn't be
+    # determined from the filename. By default `Rack::Mime` will be used for
+    # inferring the extension, but you can also choose a different inferrer:
+    #
+    #     plugin :infer_extension, inferrer: :mime_types
+    #
+    # The following inferrers are accepted:
+    #
+    # :rack_mime
+    # : (Default). Uses the `Rack::Mime` module to infer the appropriate
+    #   extension from MIME type.
+    #
+    # :mime_types
+    # : Uses the [mime-types] gem to infer the appropriate extension from MIME
+    #   type.
+    #
+    # :mini_mime
+    # : Uses the [mini_mime] gem to infer the appropriate extension from MIME
+    #   type.
+    #
+    # You can also define your own inferrer, with the possibility to call the
+    # built-in inferrers:
+    #
+    #     plugin :infer_extension, inferrer: -> (mime_type, inferrers) do
+    #       # don't add extension if the file is a text file
+    #       inferrrs[:rack_mime].call(mime_type) unless mime_type == "text/plain"
+    #     end
+    #
+    # You can also use methods for inferring extension directly:
+    #
+    #     Shrine.infer_extension("image/jpeg")
+    #     # => ".jpeg"
+    #
+    #     Shrine.extension_inferrers[:mime_types].call("image/jpeg")
+    #     # => ".jpeg"
+    #
+    # [mime-types]: https://github.com/mime-types/ruby-mime-types
+    # [mini_mime]: https://github.com/discourse/mini_mime
+    module InferExtension
+      def self.configure(uploader, opts = {})
+        uploader.opts[:extension_inferrer] = opts.fetch(:inferrer, uploader.opts.fetch(:infer_extension_inferrer, :rack_mime))
+      end
+
+      module ClassMethods
+        def infer_extension(mime_type)
+          inferrer = opts[:extension_inferrer]
+          inferrer = extension_inferrers[inferrer] if inferrer.is_a?(Symbol)
+          args     = [mime_type, extension_inferrers].take(inferrer.arity.abs)
+
+          inferrer.call(*args)
+        end
+
+        def extension_inferrers
+          @extension_inferrers ||= ExtensionInferrer::SUPPORTED_TOOLS.inject({}) do |hash, tool|
+            hash.merge!(tool => ExtensionInferrer.new(tool).method(:call))
+          end
+        end
+      end
+
+      module InstanceMethods
+        def generate_location(io, context = {})
+          mime_type = (context[:metadata] || {})["mime_type"]
+
+          location  = super
+          location += infer_extension(mime_type) if File.extname(location).empty?
+          location
+        end
+
+        private
+
+        def infer_extension(mime_type)
+          self.class.infer_extension(mime_type).to_s
+        end
+      end
+
+      class ExtensionInferrer
+        SUPPORTED_TOOLS = [:rack_mime, :mime_types, :mini_mime]
+
+        def initialize(tool)
+          raise ArgumentError, "unsupported extension inferrer tool: #{tool}" unless SUPPORTED_TOOLS.include?(tool)
+
+          @tool = tool
+        end
+
+        def call(mime_type)
+          return nil if mime_type.nil?
+
+          extension = send(:"infer_with_#{@tool}", mime_type)
+          extension = ".#{extension}" unless extension.nil? || extension.start_with?(".")
+          extension
+        end
+
+        private
+
+        def infer_with_rack_mime(mime_type)
+          require "rack/mime"
+
+          mime_types = Rack::Mime::MIME_TYPES
+          mime_types.key(mime_type)
+        end
+
+        def infer_with_mime_types(mime_type)
+          require "mime/types"
+
+          mime_type = MIME::Types[mime_type].first
+          mime_type.preferred_extension if mime_type
+        end
+
+        def infer_with_mini_mime(mime_type)
+          require "mini_mime"
+
+          info = MiniMime.lookup_by_content_type(mime_type)
+          info.extension if info
+        end
+      end
+    end
+
+    register_plugin(:infer_extension, InferExtension)
+  end
+end

data/lib/shrine/plugins/keep_files.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `keep_files` plugin gives you the ability to prevent files from being

data/lib/shrine/plugins/logging.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "logger"
 require "json"
 require "time"
@@ -74,7 +76,7 @@ class Shrine
         # doesn't output timestamps if on Heroku.
         def pretty_formatter
           proc do |severity, time, program_name, message|
-            output = "#{Process.pid}: #{message}\n"
+            output = "#{Process.pid}: #{message}\n".dup
             output.prepend "#{time.utc.iso8601(3)} " unless ENV["DYNO"]
             output
           end
@@ -123,11 +125,11 @@ class Shrine
         def _log_message_human(data)
           components = []
           components << "#{data[:action].upcase}"
-          components.last << "[#{data[:phase]}]" if data[:phase]
+          components[-1] += "[#{data[:phase]}]" if data[:phase]
           components << "#{data[:uploader]}"
-          components.last << "[:#{data[:attachment]}]" if data[:attachment]
+          components[-1] += "[:#{data[:attachment]}]" if data[:attachment]
           components << "#{data[:record_class]}" if data[:record_class]
-          components.last << "[#{data[:record_id]}]" if data[:record_id]
+          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(" ")

data/lib/shrine/plugins/metadata_attributes.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `metadata_attributes` plugin allows you to sync attachment metadata

data/lib/shrine/plugins/migration_helpers.rb

@@ -1,3 +1,5 @@
+# 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

data/lib/shrine/plugins/module_include.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `module_include` plugin allows you to extend Shrine's core classes for

data/lib/shrine/plugins/moving.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `moving` plugin will *move* files to storages instead of copying them,

data/lib/shrine/plugins/multi_delete.rb

@@ -1,3 +1,7 @@
+# frozen_string_literal: true
+
+Shrine.deprecation("The multi_delete plugin is deprecated and will be removed in Shrine 3.")
+
 class Shrine
   module Plugins
     # The `multi_delete` plugins allows you to leverage your storage's multi

data/lib/shrine/plugins/parallelize.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "thread"
 
 class Shrine

data/lib/shrine/plugins/parsed_json.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 class Shrine
   module Plugins
     # The `parsed_json` plugin is suitable for the case when your framework is

data/lib/shrine/plugins/presign_endpoint.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require "rack"
 
 require "json"
@@ -6,10 +8,10 @@ class Shrine
   module Plugins
     # The `presign_endpoint` plugin provides a Rack endpoint which generates
     # the URL, fields, and headers that can be used to upload files directly to
-    # a storage service. It can be used with client-side file upload libraries
-    # like [FineUploader], [Dropzone] or [jQuery-File-Upload] for asynchronous
-    # uploads. Storage services that support direct uploads include [Amazon
-    # S3], [Google Cloud Storage], [Microsoft Azure Storage] and more.
+    # a storage service. On the client side it's recommended to use [Uppy] for
+    # asynchronous uploads. Storage services that support direct uploads
+    # include [Amazon S3], [Google Cloud Storage], [Microsoft Azure Storage]
+    # and more.
     #
     #     plugin :presign_endpoint
     #
@@ -112,9 +114,7 @@ class Shrine
     #
     #     Shrine.presign_endpoint(:cache, presign_location: "${filename}")
     #
-    # [FineUploader]: https://github.com/FineUploader/fine-uploader
-    # [Dropzone]: https://github.com/enyo/dropzone
-    # [jQuery-File-Upload]: https://github.com/blueimp/jQuery-File-Upload
+    # [Uppy]: https://uppy.io
     # [Amazon S3]: https://aws.amazon.com/s3/
     # [Google Cloud Storage]: https://cloud.google.com/storage/
     # [Microsoft Azure Storage]: https://azure.microsoft.com/en-us/services/storage/