shrine 2.9.0 → 2.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3eaf93cef812b79947acfc7c7430ef325d9a491d
-  data.tar.gz: 0f303e9d11e6068d7fea7d9ee82de5f3b0366ae4
+  metadata.gz: 5820e9c06eec70c66a52ff3cc099847651076e2e
+  data.tar.gz: 6328bfb5edf7cb31a0e6b8ebb8a0815483451314
 SHA512:
-  metadata.gz: 4fe0e87ded5e804acfa29876e7b1f3fc777cfb8ba1fcb3f579d82f108db6df526e9fe1c606a9058ed6071985e94408cace9d0584656421d7daf83b16302617a6
-  data.tar.gz: 98553462acfd41d1f24de296c82cbe12f4be7333693e2e4acd436416a524e7d348a0169248b7ea60d168462814e9e52d48a35afa6f642eb7dfc1592d72abfca7
+  metadata.gz: 41411c21937516fb928e686378c8b2d16a3a30ae9f1bf15c47010863a7d39c676c6a9ded87cad0a48f95108e1cc6dfc7e3cfab5363d79e73f3f14505fa05a9b9
+  data.tar.gz: 832a9a41216b0c2406b327bbb442aa0f82af69973afef87f7ee99abcc72ddde3d5634330f8b8cb9fc123589a171fd61cd2754079999d2e0d5d643f9ae493fe44

data/CHANGELOG.md

@@ -1,3 +1,25 @@
+## 2.10.0 (2018-03-28)
+
+* Add `:fastimage` analyzer to `determine_mime_type` plugin (@mokolabs)
+
+* Keep download endpoint URL the same regardless of metadata ordering (@MSchmidt)
+
+* Remove `:rack_mime` extension inferrer from the `infer_extension` plugin (@janko-m)
+
+* Allow `UploadedFile#download` to accept a block for temporary file download (@janko-m)
+
+* Add `:ruby_vips` analyzer to `store_dimensions` plugin (@janko-m)
+
+* Add `:mini_magick` analyzer to `store_dimensions` plugin (@janko-m)
+
+* Soft-rename `:heroku` logging format to `:logfmt` (@janko-m)
+
+* Deprecate `Shrine::IO_METHODS` constant (@janko-m)
+
+* Don't require IO size to be known on upload (@janko-m)
+
+* Inherit the logger on subclassing `Shrine` and make it shared across subclasses (@hmistry)
+
 ## 2.9.0 (2018-01-27)
 
 * Support arrays of files in `versions` plugin (@janko-m)

data/README.md

@@ -8,8 +8,8 @@ If you're not sure why you should care, you're encouraged to read the
 ## Resources
 
 - Documentation: [shrinerb.com](http://shrinerb.com)
-- Source: [github.com/janko-m/shrine](https://github.com/janko-m/shrine)
-- Bugs: [github.com/janko-m/shrine/issues](https://github.com/janko-m/shrine/issues)
+- Source: [github.com/shrinerb/shrine](https://github.com/shrinerb/shrine)
+- Bugs: [github.com/shrinerb/shrine/issues](https://github.com/shrinerb/shrine/issues)
 - Help & Discussion: [groups.google.com/group/ruby-shrine](https://groups.google.com/forum/#!forum/ruby-shrine)
 
 ## Quick start
@@ -238,10 +238,14 @@ It comes with many convenient methods that delegate to the storage:
 
 ```rb
 uploaded_file.url      #=> "https://my-bucket.s3.amazonaws.com/949sdjg834.jpg"
-uploaded_file.download #=> #<Tempfile>
+uploaded_file.open     #=> IO object
+uploaded_file.download #=> #<File:/var/folders/.../20180302-33119-1h1vjbq.jpg>
 uploaded_file.exists?  #=> true
-uploaded_file.open { |io| io.read }
-uploaded_file.delete
+uploaded_file.delete   # deletes the file from the storage
+
+# open/download the uploaded file for the duration of the block
+uploaded_file.open     { |io| io.read }
+uploaded_file.download { |tempfile| tempfile.read }
 ```
 
 It also implements the IO-like interface that conforms to Shrine's IO
@@ -500,18 +504,25 @@ images, I created the [image_processing] gem which you can use with Shrine:
 
 ```rb
 # Gemfile
-gem "image_processing"
-gem "mini_magick", ">= 4.3.5"
+gem "image_processing", "~> 0.10"
+gem "mini_magick", "~> 4.0"
 ```
 ```rb
 require "image_processing/mini_magick"
 
 class ImageUploader < Shrine
-  include ImageProcessing::MiniMagick
   plugin :processing
 
   process(:store) do |io, context|
-    resize_to_limit!(io.download, 800, 800) { |cmd| cmd.auto_orient } # orient rotated images
+    original = io.download
+
+    resized = ImageProcessing::MiniMagick
+      .source(original)
+      .resize_to_limit!(800, 800)
+
+    original.close!
+
+    resized
   end
 end
 ```
@@ -541,19 +552,21 @@ deleted after uploading.
 require "image_processing/mini_magick"
 
 class ImageUploader < Shrine
-  include ImageProcessing::MiniMagick
   plugin :processing
   plugin :versions   # enable Shrine to handle a hash of files
   plugin :delete_raw # delete processed files after uploading
 
   process(:store) do |io, context|
     original = io.download
+    pipeline = ImageProcessing::MiniMagick.source(original)
+
+    size_800 = pipeline.resize_to_limit!(800, 800)
+    size_500 = pipeline.resize_to_limit!(500, 500)
+    size_300 = pipeline.resize_to_limit!(300, 300)
 
-    size_800 = resize_to_limit!(original, 800, 800) { |cmd| cmd.auto_orient } # orient rotated images
-    size_500 = resize_to_limit(size_800,  500, 500)
-    size_300 = resize_to_limit(size_500,  300, 300)
+    original.close!
 
-    {original: io, large: size_800, medium: size_500, small: size_300}
+    { original: io, large: size_800, medium: size_500, small: size_300 }
   end
 end
 ```
@@ -679,9 +692,11 @@ user.errors.to_hash #=> {cv: ["is too large (max is 5 MB)"]}
 You can also do custom validations:
 
 ```rb
-class DocumentUploader < Shrine
+class ImageUploader < Shrine
   Attacher.validate do
-    errors << "has more than 3 pages" if get.metadata["pages"] > 3
+    get.download do |tempfile|
+      errors << "image is corrupted" unless ImageProcessing::MiniMagick.valid_image?(tempfile)
+    end
   end
 end
 ```
@@ -1010,7 +1025,7 @@ The gem is available as open source under the terms of the [MIT License].
 [plugins]: http://shrinerb.com/#plugins
 [`file`]: http://linux.die.net/man/1/file
 [backgrounding]: http://shrinerb.com/rdoc/classes/Shrine/Plugins/Backgrounding.html
-[Context]: https://github.com/janko-m/shrine#context
+[Context]: https://github.com/shrinerb/shrine#context
 [image_processing]: https://github.com/janko-m/image_processing
 [ffmpeg]: https://github.com/streamio/streamio-ffmpeg
 [Uppy]: https://uppy.io
@@ -1019,22 +1034,22 @@ The gem is available as open source under the terms of the [MIT License].
 [Microsoft Azure Storage]: https://azure.microsoft.com/en-us/services/storage/
 [upload_endpoint]: http://shrinerb.com/rdoc/classes/Shrine/Plugins/UploadEndpoint.html
 [presign_endpoint]: http://shrinerb.com/rdoc/classes/Shrine/Plugins/PresignEndpoint.html
-[Cloudinary]: https://github.com/janko-m/shrine-cloudinary
-[Imgix]: https://github.com/janko-m/shrine-imgix
-[Uploadcare]: https://github.com/janko-m/shrine-uploadcare
+[Cloudinary]: https://github.com/shrinerb/shrine-cloudinary
+[Imgix]: https://github.com/shrinerb/shrine-imgix
+[Uploadcare]: https://github.com/shrinerb/shrine-uploadcare
 [Dragonfly]: http://markevans.github.io/dragonfly/
 [tus]: http://tus.io
 [tus-ruby-server]: https://github.com/janko-m/tus-ruby-server
 [tus-js-client]: https://github.com/tus/tus-js-client
-[shrine-tus-demo]: https://github.com/janko-m/shrine-tus-demo
-[shrine-url]: https://github.com/janko-m/shrine-url
+[shrine-tus-demo]: https://github.com/shrinerb/shrine-tus-demo
+[shrine-url]: https://github.com/shrinerb/shrine-url
 [Roda]: https://github.com/jeremyevans/roda
 [Refile]: https://github.com/refile/refile
 [MIT License]: http://opensource.org/licenses/MIT
-[CoC]: https://github.com/janko-m/shrine/blob/master/CODE_OF_CONDUCT.md
-[roda_demo]: https://github.com/janko-m/shrine/tree/master/demo
+[CoC]: https://github.com/shrinerb/shrine/blob/master/CODE_OF_CONDUCT.md
+[roda_demo]: https://github.com/shrinerb/shrine/tree/master/demo
 [rails_demo]: https://github.com/erikdahlstrand/shrine-rails-example
-[backgrounding libraries]: https://github.com/janko-m/shrine/wiki/Backgrounding-libraries
+[backgrounding libraries]: https://github.com/shrinerb/shrine/wiki/Backgrounding-libraries
 [S3 lifecycle Console]: http://docs.aws.amazon.com/AmazonS3/latest/UG/lifecycle-configuration-bucket-no-versioning.html
 [S3 lifecycle API]: https://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Client.html#put_bucket_lifecycle_configuration-instance_method
 [processing post]: https://twin.github.io/better-file-uploads-with-shrine-processing/

data/doc/carrierwave.md

@@ -90,17 +90,23 @@ end
 ```
 
 ```rb
+require "image_processing/mini_magick"
+
 class ImageUploader < Shrine
-  include ImageProcessing::MiniMagick
   plugin :processing
   plugin :versions
 
   process(:store) do |io, context|
-    size_800 = resize_to_limit(io.download, 800, 800)
-    size_500 = resize_to_limit(size_800,    500, 500)
-    size_300 = resize_to_limit(size_500,    300, 300)
+    original = io.download
+    pipeline = ImageProcessing::MiniMagick.source(original)
+
+    size_800 = pipeline.resize_to_limit!(800, 800)
+    size_500 = pipeline.resize_to_limit!(500, 500)
+    size_300 = pipeline.resize_to_limit!(300, 300)
+
+    original.close!
 
-    {original: size_800, medium: size_500, small: size_300}
+    { original: size_800, medium: size_500, small: size_300 }
   end
 end
 ```
@@ -700,14 +706,14 @@ plugin :default_url_options, store: {expires_in: 600}
 Shrine allows you to override the S3 endpoint:
 
 ```rb
-Shrine::Storage::S3.new(endnpoint: "https://s3-accelerate.amazonaws.com", **options)
+Shrine::Storage::S3.new(endpoint: "https://s3-accelerate.amazonaws.com", **options)
 ```
 
 [image_processing]: https://github.com/janko-m/image_processing
-[demo app]: https://github.com/janko-m/shrine/tree/master/demo
+[demo app]: https://github.com/shrinerb/shrine/tree/master/demo
 [Reprocessing versions]: http://shrinerb.com/rdoc/files/doc/regenerating_versions_md.html
-[shrine-fog]: https://github.com/janko-m/shrine-fog
+[shrine-fog]: https://github.com/shrinerb/shrine-fog
 [direct uploads]: http://shrinerb.com/rdoc/files/doc/direct_s3_md.html
 [`Shrine::Storage::S3`]: http://shrinerb.com/rdoc/classes/Shrine/Storage/S3.html
 [`Shrine::Storage::GoogleCloudStorage`]: https://github.com/renchap/shrine-google_cloud_storage
-[`Shrine::Storage::Fog`]: https://github.com/janko-m/shrine-fog
+[`Shrine::Storage::Fog`]: https://github.com/shrinerb/shrine-fog

data/doc/creating_storages.md

@@ -226,4 +226,4 @@ tests for your storage. There will likely be some edge cases that won't be
 tested by the linter.
 
 [HTTP.rb]: https://github.com/httprb/http
-[fake IO]: https://github.com/janko-m/shrine-cloudinary/blob/ca587c580ea0762992a2df33fd590c9a1e534905/test/test_helper.rb#L20-L27
+[fake IO]: https://github.com/shrinerb/shrine-cloudinary/blob/ca587c580ea0762992a2df33fd590c9a1e534905/test/test_helper.rb#L20-L27

data/doc/direct_s3.md

@@ -299,7 +299,7 @@ s3.clear! { |object| object.last_modified < Time.now - 7*24*60*60 } # delete fil
 ```
 
 Alternatively you can add a bucket lifeycle rule to do this for you. This can
-be done either from the [AWS Console][lifecycle console] or via an [API
+be done either from the [AWS Console][lifecycle Console] or via an [API
 call][lifecycle API]:
 
 ```rb
@@ -354,7 +354,7 @@ end
 ```
 
 [`Aws::S3::PresignedPost`]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Bucket.html#presigned_post-instance_method
-[demo app]: https://github.com/janko-m/shrine/tree/master/demo
+[demo app]: https://github.com/shrinerb/shrine/tree/master/demo
 [Uppy]: https://uppy.io
 [Amazon S3 Data Consistency Model]: http://docs.aws.amazon.com/AmazonS3/latest/dev/Introduction.html#ConsistencyMode
 [CORS guide]: http://docs.aws.amazon.com/AmazonS3/latest/dev/cors.html

data/doc/paperclip.md

@@ -95,17 +95,23 @@ end
 ```
 
 ```rb
+require "image_processing/mini_magick"
+
 class ImageUploader < Shrine
-  include ImageProcessing::MiniMagick
   plugin :processing
   plugin :versions
 
   process(:store) do |io, context|
-    size_800 = resize_to_limit(io.download, 800, 800)
-    size_500 = resize_to_limit(size_800,    500, 500)
-    size_300 = resize_to_limit(size_500,    300, 300)
+    original = io.download
+    pipeline = ImageProcessing::MiniMagick.source(original)
+
+    size_800 = pipeline.resize_to_limit!(800, 800)
+    size_500 = pipeline.resize_to_limit!(500, 500)
+    size_300 = pipeline.resize_to_limit!(300, 300)
+
+    original.close!
 
-    {large: size_800, medium: size_500, small: size_300}
+    { original: io, large: size_800, medium: size_500, small: size_300 }
   end
 end
 ```

data/doc/refile.md

@@ -65,17 +65,23 @@ an open-source solution, [Attache], which you can also use with Shrine.
 This is how you would process multiple versions in Shrine:
 
 ```rb
+require "image_processing/mini_magick"
+
 class ImageUploader < Shrine
-  include ImageProcessing::MiniMagick
   plugin :processing
   plugin :versions
 
   process(:store) do |io, context|
-    size_800 = resize_to_limit(io.download, 800, 800)
-    size_500 = resize_to_limit(size_800,    500, 500)
-    size_300 = resize_to_limit(size_500,    300, 300)
+    original = io.download
+    pipeline = ImageProcessing::MiniMagick.source(original)
+
+    size_800 = pipeline.resize_to_limit!(800, 800)
+    size_500 = pipeline.resize_to_limit!(500, 500)
+    size_300 = pipeline.resize_to_limit!(300, 300)
+
+    original.close!
 
-    {original: size_800, medium: size_500, small: size_300}
+    { original: io, large: size_800, medium: size_500, small: size_300 }
   end
 end
 ```
@@ -473,12 +479,12 @@ Shrine.plugin :remote_url
 <% end %>
 ```
 
-[shrine-cloudinary]: https://github.com/janko-m/shrine-cloudinary
-[shrine-imgix]: https://github.com/janko-m/shrine-imgix
-[shrine-uploadcare]: https://github.com/janko-m/shrine-uploadcare
+[shrine-cloudinary]: https://github.com/shrinerb/shrine-cloudinary
+[shrine-imgix]: https://github.com/shrinerb/shrine-imgix
+[shrine-uploadcare]: https://github.com/shrinerb/shrine-uploadcare
 [Attache]: https://github.com/choonkeat/attache
 [image_processing]: https://github.com/janko-m/image_processing
 [Uppy]: https://uppy.io
 [Direct Uploads to S3]: http://shrinerb.com/rdoc/files/doc/direct_s3_md.html
-[demo app]: https://github.com/janko-m/shrine/tree/master/demo
+[demo app]: https://github.com/shrinerb/shrine/tree/master/demo
 [Multiple Files]: http://shrinerb.com/rdoc/files/doc/multiple_files_md.html

data/doc/testing.md

@@ -169,7 +169,7 @@ class FakeIO
   end
 
   extend Forwardable
-  delegate Shrine::IO_METHODS.keys => :@io
+  delegate %i[read rewind eof? close size] => :@io
 end
 ```
 
@@ -251,25 +251,38 @@ storage server with Amazon S3 compatible API. If you're on a Mac you can
 install it with Homebrew:
 
 ```
-$ brew install minio
-$ minio server data/
+$ brew install minio/stable/minio
 ```
 
-Then you can open the Minio UI in the browser and create a new bucket. Once
-you've done that, all that's left to do is point aws-sdk-s3 to your Minio
-server:
+Now you can start the Minio server and give it a directory where it will store
+the data:
 
 ```
+$ minio server data/
+```
+
+This command will print out the credentials for the running Minio server, as
+well as a link to the Minio web interface. Follow that link and create a new
+bucket. Once you've done that, all that's lef to do is configure
+`Shrine::Storage::S3` with the credentials of your Minio server:
+
+```rb
 Shrine::Storage::S3.new(
-  access_key_id:     "MINIO_ACCESS_KEY_ID",
-  secret_access_key: "MINIO_SECRET_ACCESS_KEY",
-  bucket:            "MINIO_BUCKET",
+  access_key_id:     "MINIO_ACCESS_KEY", # "AccessKey" value
+  secret_access_key: "MINIO_SECRET_KEY", # "SecretKey" value
+  endpoint:          "MINIO_ENDPOINT",   # "Endpoint"  value
+  bucket:            "MINIO_BUCKET",     # name of the bucket you created
   region:            "us-east-1",
+  force_path_style:  true,
 )
 ```
 
+The `:endpoint` option will make `aws-sdk-s3` point all URLs to your Minio
+server (instead of `s3.amazonaws.com`), and `:force_path_style` tells it not
+to use subdomains when generating URLs.
+
 [DatabaseCleaner]: https://github.com/DatabaseCleaner/database_cleaner
-[shrine-memory]: https://github.com/janko-m/shrine-memory
+[shrine-memory]: https://github.com/shrinerb/shrine-memory
 [factory_bot]: https://github.com/thoughtbot/factory_bot
 [Capybara]: https://github.com/jnicklas/capybara
 [`#attach_file`]: http://www.rubydoc.info/github/jnicklas/capybara/master/Capybara/Node/Actions#attach_file-instance_method

data/lib/shrine.rb

@@ -13,17 +13,7 @@ class Shrine
   # Raised when a file is not a valid IO.
   class InvalidFile < Error
     def initialize(io, missing_methods)
-      @io, @missing_methods = io, missing_methods
-    end
-
-    def message
-      "#{@io.inspect} is not a valid IO object (it doesn't respond to #{missing_methods_string})"
-    end
-
-    private
-
-    def missing_methods_string
-      @missing_methods.map { |m, args| "##{m}" }.join(", ")
+      super "#{io.inspect} is not a valid IO object (it doesn't respond to #{missing_methods.map{|m, args|"##{m}"}.join(", ")})"
     end
   end
 
@@ -36,6 +26,7 @@ class Shrine
     size:   [],
     close:  [],
   }
+  deprecate_constant(:IO_METHODS) if RUBY_VERSION > "2.3"
 
   # Core class that represents a file uploaded to a storage. The instance
   # methods for this class are added by Shrine::Plugins::Base::FileMethods, the
@@ -289,7 +280,7 @@ class Shrine
 
         # Extracts the filesize from the IO object.
         def extract_size(io)
-          io.size
+          io.size if io.respond_to?(:size)
         end
 
         # It first asserts that `io` is a valid IO object. It then extracts
@@ -366,7 +357,7 @@ class Shrine
         # object doesn't respond to one of these methods, a Shrine::InvalidFile
         # error is raised.
         def _enforce_io(io)
-          missing_methods = IO_METHODS.select { |m, a| !io.respond_to?(m) }
+          missing_methods = %i[read eof? rewind close].select { |m| !io.respond_to?(m) }
           raise InvalidFile.new(io, missing_methods) if missing_methods.any?
         end
 
@@ -778,13 +769,24 @@ class Shrine
         end
         alias content_type mime_type
 
-        # Opens an IO object of the uploaded file for reading, yields it to
-        # the block, and closes it after the block finishes. If opening without
-        # a block, it returns an opened IO object for the uploaded file.
+        # Calls `#open` on the storage to open the uploaded file for reading.
+        # Most storages will return a lazy IO object which dynamically
+        # retrieves file content from the storage as the object is being read.
         #
-        #     uploaded_file.open do |io|
-        #       puts io.read # prints the content of the file
-        #     end
+        # If a block is given, the opened IO object is yielded to the block,
+        # and at the end of the block it's automatically closed. In this case
+        # the return value of the method is the block return value.
+        #
+        # If no block is given, the opened IO object is returned.
+        #
+        #     uploaded_file.open #=> IO object returned by the storage
+        #     uploaded_file.read #=> "..."
+        #     uploaded_file.close
+        #
+        #     # or
+        #
+        #     uploaded_file.open { |io| io.read }
+        #     #=> "..."
         def open(*args)
           return to_io unless block_given?
 
@@ -799,19 +801,33 @@ class Shrine
 
         # Calls `#download` on the storage if the storage implements it,
         # otherwise uses #open to stream the underlying IO to a Tempfile.
+        #
+        # If a block is given, the opened Tempfile object is yielded to the
+        # block, and at the end of the block it's automatically closed and
+        # deleted. In this case the return value of the method is the block
+        # return value.
+        #
+        # If no block is given, the opened Tempfile is returned.
+        #
+        #     uploaded_file.download
+        #     #=> #<File:/var/folders/.../20180302-33119-1h1vjbq.jpg>
+        #
+        #     # or
+        #
+        #     uploaded_file.download { |tempfile| tempfile.read } # tempfile is deleted
+        #     #=> "..."
         def download(*args)
           if storage.respond_to?(:download)
-            storage.download(id, *args)
+            tempfile = storage.download(id, *args)
           else
-            begin
-              tempfile = Tempfile.new(["shrine", ".#{extension}"], binmode: true)
-              open(*args) { |io| IO.copy_stream(io, tempfile.path) }
-              tempfile.tap(&:open)
-            rescue
-              tempfile.close! if tempfile
-              raise
-            end
+            tempfile = Tempfile.new(["shrine", ".#{extension}"], binmode: true)
+            open(*args) { |io| IO.copy_stream(io, tempfile) }
+            tempfile.open
           end
+
+          block_given? ? yield(tempfile) : tempfile
+        ensure
+          tempfile.close! if ($! || block_given?) && tempfile
         end
 
         # Part of complying to the IO interface. It delegates to the internally

data/lib/shrine/plugins/determine_mime_type.rb

@@ -20,6 +20,10 @@ class Shrine
     #   contents. It is installed by default on most operating systems, but the
     #   [Windows equivalent] needs to be installed separately.
     #
+    # :fastimage
+    # : Uses the [fastimage] gem to determine the MIME type from file contents.
+    #   Fastimage is optimized for speed over accuracy. Best used for image content.
+    #
     # :filemagic
     # : Uses the [ruby-filemagic] gem to determine the MIME type from file
     #   contents, using a similar MIME database as the `file` utility. Unlike
@@ -81,6 +85,7 @@ class Shrine
     # [marcel]: https://github.com/basecamp/marcel
     # [mime-types]: https://github.com/mime-types/ruby-mime-types
     # [mini_mime]: https://github.com/discourse/mini_mime
+    # [fastimage]: https://github.com/sdsykes/fastimage
     module DetermineMimeType
       def self.configure(uploader, opts = {})
         uploader.opts[:mime_type_analyzer] = opts.fetch(:analyzer, uploader.opts.fetch(:mime_type_analyzer, :file))
@@ -94,7 +99,7 @@ class Shrine
             mime_type = io.content_type if io.respond_to?(:content_type)
           else
             analyzer = opts[:mime_type_analyzer]
-            analyzer = mime_type_analyzers[analyzer] if analyzer.is_a?(Symbol)
+            analyzer = mime_type_analyzer(analyzer) if analyzer.is_a?(Symbol)
             args     = [io, mime_type_analyzers].take(analyzer.arity.abs)
 
             mime_type = analyzer.call(*args)
@@ -109,9 +114,14 @@ class Shrine
         # IO object.
         def mime_type_analyzers
           @mime_type_analyzers ||= MimeTypeAnalyzer::SUPPORTED_TOOLS.inject({}) do |hash, tool|
-            hash.merge!(tool => MimeTypeAnalyzer.new(tool).method(:call))
+            hash.merge!(tool => mime_type_analyzer(tool))
           end
         end
+
+        # Returns callable mime type analyzer object.
+        def mime_type_analyzer(name)
+          MimeTypeAnalyzer.new(name).method(:call)
+        end
       end
 
       module InstanceMethods
@@ -135,11 +145,11 @@ class Shrine
       end
 
       class MimeTypeAnalyzer
-        SUPPORTED_TOOLS = [:file, :filemagic, :mimemagic, :marcel, :mime_types, :mini_mime]
+        SUPPORTED_TOOLS = [:fastimage, :file, :filemagic, :mimemagic, :marcel, :mime_types, :mini_mime]
         MAGIC_NUMBER    = 256 * 1024
 
         def initialize(tool)
-          raise ArgumentError, "unsupported mime type analysis tool: #{tool}" unless SUPPORTED_TOOLS.include?(tool)
+          raise Error, "unknown mime type analyzer #{tool.inspect}, supported analyzers are: #{SUPPORTED_TOOLS.join(",")}" unless SUPPORTED_TOOLS.include?(tool)
 
           @tool = tool
         end
@@ -176,6 +186,13 @@ class Shrine
           raise Error, "The `file` command-line tool is not installed"
         end
 
+        def extract_with_fastimage(io)
+          require "fastimage"
+
+          type = FastImage.type(io)
+          "image/#{type}" if type
+        end
+
         def extract_with_filemagic(io)
           require "filemagic"
 

data/lib/shrine/plugins/download_endpoint.rb

@@ -131,7 +131,7 @@ class Shrine
         # long.
         def download_identifier
           semantical_metadata = metadata.select { |name, _| %w[filename size mime_type].include?(name) }
-          download_serializer.dump(data.merge("metadata" => semantical_metadata))
+          download_serializer.dump(data.merge("metadata" => semantical_metadata.sort.to_h))
         end
 
         def download_serializer

data/lib/shrine/plugins/infer_extension.rb

@@ -10,19 +10,15 @@ class Shrine
     #     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
+    # determined from the filename. By default `MIME::Types` will be used for
     # inferring the extension, but you can also choose a different inferrer:
     #
-    #     plugin :infer_extension, inferrer: :mime_types
+    #     plugin :infer_extension, inferrer: :mini_mime
     #
     # 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
+    # : (Default). Uses the [mime-types] gem to infer the appropriate extension from MIME
     #   type.
     #
     # :mini_mime
@@ -49,13 +45,13 @@ class Shrine
     # [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))
+        uploader.opts[:extension_inferrer] = opts.fetch(:inferrer, uploader.opts.fetch(:infer_extension_inferrer, :mime_types))
       end
 
       module ClassMethods
         def infer_extension(mime_type)
           inferrer = opts[:extension_inferrer]
-          inferrer = extension_inferrers[inferrer] if inferrer.is_a?(Symbol)
+          inferrer = extension_inferrer(inferrer) if inferrer.is_a?(Symbol)
           args     = [mime_type, extension_inferrers].take(inferrer.arity.abs)
 
           inferrer.call(*args)
@@ -63,9 +59,13 @@ class Shrine
 
         def extension_inferrers
           @extension_inferrers ||= ExtensionInferrer::SUPPORTED_TOOLS.inject({}) do |hash, tool|
-            hash.merge!(tool => ExtensionInferrer.new(tool).method(:call))
+            hash.merge!(tool => extension_inferrer(tool))
           end
         end
+
+        def extension_inferrer(name)
+          ExtensionInferrer.new(name).method(:call)
+        end
       end
 
       module InstanceMethods
@@ -85,10 +85,10 @@ class Shrine
       end
 
       class ExtensionInferrer
-        SUPPORTED_TOOLS = [:rack_mime, :mime_types, :mini_mime]
+        SUPPORTED_TOOLS = [:mime_types, :mini_mime]
 
         def initialize(tool)
-          raise ArgumentError, "unsupported extension inferrer tool: #{tool}" unless SUPPORTED_TOOLS.include?(tool)
+          raise Error, "unknown extension inferrer #{tool.inspect}, supported inferrers are: #{SUPPORTED_TOOLS.join(",")}" unless SUPPORTED_TOOLS.include?(tool)
 
           @tool = tool
         end
@@ -103,13 +103,6 @@ class Shrine
 
         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"
 

data/lib/shrine/plugins/logging.rb

@@ -22,7 +22,7 @@ class Shrine
     #
     # :format
     # :  This allows you to change the logging output into something that may be
-    #    easier to grep. Accepts `:human` (default), `:json` and `:heroku`.
+    #    easier to grep. Accepts `:human` (default), `:json` and `:logfmt`.
     #
     # :stream
     # :  The default logging stream is `$stdout`, but you may want to change it,
@@ -40,7 +40,7 @@ class Shrine
     #     plugin :logging, format: :json
     #     # {"action":"upload","phase":"cache","uploader":"ImageUploader","attachment":"avatar",...}
     #
-    #     plugin :logging, format: :heroku
+    #     plugin :logging, format: :logfmt
     #     # 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
@@ -51,25 +51,28 @@ class Shrine
       end
 
       def self.configure(uploader, opts = {})
-        uploader.opts[:logging_logger] = opts.fetch(:logger, uploader.opts[:logging_logger])
         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 || Logger.new(nil)
+          @logger = logger
         end
 
-        # Initializes a new logger if it hasn't been initialized.
         def logger
-          @logger ||= opts[:logging_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
-          )
+          @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
@@ -140,10 +143,11 @@ class Shrine
           JSON.generate(data)
         end
 
-        def _log_message_heroku(data)
+        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.

data/lib/shrine/plugins/processing.rb

@@ -31,18 +31,28 @@ class Shrine
     #
     # An example of resizing an image using the [image_processing] library:
     #
-    #     include ImageProcessing::MiniMagick
+    #     require "image_processing/mini_magick"
     #
     #     process(:store) do |io, context|
-    #       resize_to_limit!(io.download, 800, 800)
+    #       original = io.download
+    #
+    #       resized = ImageProcessing::MiniMagick
+    #         .source(original)
+    #         .resize_to_limit!(800, 800)
+    #
+    #       original.close!
+    #
+    #       resized
     #     end
     #
     # The declarations are additive and inheritable, so for the same action you
     # can declare multiple blocks, and they will be performed in the same order,
     # with output from previous block being the input to next.
     #
-    # You can manually trigger the defined processing via the uploader, you
-    # just need to specify `:action` to the name of your processing block:
+    # ## Manually Run Processing
+    #
+    # You can manually trigger the defined processing via the uploader by calling
+    # `#upload` or `#process` and setting `:action` to the name of your processing block:
     #
     #     uploader.upload(file, action: :store)  # process and upload
     #     uploader.process(file, action: :store) # only process

data/lib/shrine/plugins/remote_url.rb

@@ -79,7 +79,7 @@ class Shrine
     #     plugin :infer_extension
     #
     # [Down]: https://github.com/janko-m/down
-    # [shrine-url]: https://github.com/janko-m/shrine-url
+    # [shrine-url]: https://github.com/shrinerb/shrine-url
     module RemoteUrl
       def self.configure(uploader, opts = {})
         raise Error, "The :max_size option is required for remote_url plugin" if !opts.key?(:max_size) && !uploader.opts.key?(:remote_url_max_size)

data/lib/shrine/plugins/signature.rb

@@ -64,8 +64,8 @@ class Shrine
         attr_reader :algorithm, :format
 
         def initialize(algorithm, format:)
-          raise ArgumentError, "hash algorithm not supported: #{algorithm}" unless SUPPORTED_ALGORITHMS.include?(algorithm)
-          raise ArgumentError, "hash format not supported: #{format}" unless SUPPORTED_FORMATS.include?(format)
+          raise Error, "unknown hash algorithm #{algorithm.inspect}, supported algorithms are: #{SUPPORTED_ALGORITHMS.join(",")}" unless SUPPORTED_ALGORITHMS.include?(algorithm)
+          raise Error, "unknown hash format #{format.inspect}, supported formats are: #{SUPPORTED_FORMATS.join(",")}" unless SUPPORTED_FORMATS.include?(format)
 
           @algorithm = algorithm
           @format    = format

data/lib/shrine/plugins/store_dimensions.rb

@@ -2,14 +2,14 @@
 
 class Shrine
   module Plugins
-    # The `store_dimensions` plugin extracts and stores dimensions of the
-    # uploaded image using the [fastimage] gem, which has built-in protection
-    # agains [image bombs].
+    # The `store_dimensions` plugin extracts dimensions of uploaded images and
+    # stores them into the metadata hash.
     #
     #     plugin :store_dimensions
     #
-    # It adds "width" and "height" metadata values to Shrine::UploadedFile,
-    # and creates `#width`, `#height` and `#dimensions` reader methods.
+    # The dimensions are stored as "width" and "height" metadata values on the
+    # Shrine::UploadedFile object. For convenience the plugin also adds
+    # `#width`, `#height` and `#dimensions` reader methods.
     #
     #     image = uploader.upload(file)
     #
@@ -21,18 +21,37 @@ class Shrine
     #     # or
     #     image.dimensions #=> [300, 500]
     #
-    # You can provide your own custom dimensions analyzer, and reuse any of the
-    # built-in analyzers; you just need to return a two-element array of width
-    # and height, or nil to signal that dimensions weren't extracted.
+    # By default the [fastimage] gem is used to extract dimensions. You can
+    # choose a different built-in analyzer via the `:analyzer` option:
     #
-    #     require "mini_magick"
+    #     plugin :store_dimensions, analyzer: :mini_magick
+    #
+    # The following analyzers are supported:
+    #
+    # :fastimage
+    # : (Default). Uses the [FastImage] gem to extract dimensions from any IO
+    #   object.
+    #
+    # :mini_magick
+    # : Uses the [MiniMagick] gem to extract dimensions from File objects. If
+    #   non-file IO object is given it will be temporarily downloaded to disk.
+    #
+    # :ruby_vips
+    # : Uses the [ruby-vips] gem to extract dimensions from File objects. If
+    #   non-file IO object is given it will be temporarily downloaded to disk.
+    #
+    # You can also create your own custom dimensions analyzer, where you can
+    # reuse any of the built-in analyzers. The analyzer is a lambda that
+    # accepts an IO object and returns width and height as a two-element array,
+    # or `nil` if dimensions could not be extracted.
     #
     #     plugin :store_dimensions, analyzer: -> (io, analyzers) do
-    #       dimensions = analyzers[:fastimage].call(io)        # try extracting dimensions with FastImage
-    #       dimensions || MiniMagick::Image.new(io).dimensions # otherwise fall back to MiniMagick
+    #       dimensions   = analyzers[:fastimage].call(io)   # try extracting dimensions with FastImage
+    #       dimensions ||= analyzers[:mini_magick].call(io) # otherwise fall back to MiniMagick
+    #       dimensions
     #     end
     #
-    # You can also use methods for extracting the dimensions directly:
+    # You can use methods for extracting the dimensions directly:
     #
     #     # or YourUploader.extract_dimensions(io)
     #     Shrine.extract_dimensions(io) # calls the defined analyzer
@@ -42,8 +61,9 @@ class Shrine
     #     Shrine.dimensions_analyzers[:fastimage].call(io) # calls a built-in analyzer
     #     #=> [300, 400]
     #
-    # [fastimage]: https://github.com/sdsykes/fastimage
-    # [image bombs]: https://www.bamsoftware.com/hacks/deflate.html
+    # [FastImage]: https://github.com/sdsykes/fastimage
+    # [MiniMagick]: https://github.com/minimagick/minimagick
+    # [ruby-vips]: https://github.com/jcupitt/ruby-vips
     module StoreDimensions
       def self.configure(uploader, opts = {})
         uploader.opts[:dimensions_analyzer] = opts.fetch(:analyzer, uploader.opts.fetch(:dimensions_analyzer, :fastimage))
@@ -54,7 +74,7 @@ class Shrine
         # analyzer.
         def extract_dimensions(io)
           analyzer = opts[:dimensions_analyzer]
-          analyzer = dimensions_analyzers[analyzer] if analyzer.is_a?(Symbol)
+          analyzer = dimensions_analyzer(analyzer) if analyzer.is_a?(Symbol)
           args = [io, dimensions_analyzers].take(analyzer.arity.abs)
 
           dimensions = analyzer.call(*args)
@@ -68,9 +88,14 @@ class Shrine
         # IO object.
         def dimensions_analyzers
           @dimensions_analyzers ||= DimensionsAnalyzer::SUPPORTED_TOOLS.inject({}) do |hash, tool|
-            hash.merge!(tool => DimensionsAnalyzer.new(tool).method(:call))
+            hash.merge!(tool => dimensions_analyzer(tool))
           end
         end
+
+        # Returns callable dimensions analyzer object.
+        def dimensions_analyzer(name)
+          DimensionsAnalyzer.new(name).method(:call)
+        end
       end
 
       module InstanceMethods
@@ -78,10 +103,7 @@ class Shrine
         def extract_metadata(io, context)
           width, height = extract_dimensions(io)
 
-          super.update(
-            "width"  => width,
-            "height" => height,
-          )
+          super.merge!("width" => width, "height" => height)
         end
 
         private
@@ -112,10 +134,10 @@ class Shrine
       end
 
       class DimensionsAnalyzer
-        SUPPORTED_TOOLS = [:fastimage]
+        SUPPORTED_TOOLS = [:fastimage, :mini_magick, :ruby_vips]
 
         def initialize(tool)
-          raise ArgumentError, "unsupported dimensions analysis tool: #{tool}" unless SUPPORTED_TOOLS.include?(tool)
+          raise Error, "unknown dimensions analyzer #{tool.inspect}, supported analyzers are: #{SUPPORTED_TOOLS.join(",")}" unless SUPPORTED_TOOLS.include?(tool)
 
           @tool = tool
         end
@@ -132,6 +154,27 @@ class Shrine
           require "fastimage"
           FastImage.size(io)
         end
+
+        def extract_with_mini_magick(io)
+          require "mini_magick"
+          ensure_file(io) { |file| MiniMagick::Image.new(file.path).dimensions }
+        end
+
+        def extract_with_ruby_vips(io)
+          require "vips"
+          ensure_file(io) { |file| Vips::Image.new_from_file(file.path).size }
+        end
+
+        def ensure_file(io)
+          if io.respond_to?(:path)
+            yield io
+          else
+            Tempfile.create("shrine-store_dimensions") do |tempfile|
+              IO.copy_stream(io, tempfile.path)
+              yield tempfile
+            end
+          end
+        end
       end
     end
 

data/lib/shrine/plugins/versions.rb

@@ -10,17 +10,21 @@ class Shrine
     # Here is an example of processing image thumbnails using the
     # [image_processing] gem:
     #
-    #     include ImageProcessing::MiniMagick
+    #     require "image_processing/mini_magick"
+    #
     #     plugin :processing
     #
     #     process(:store) do |io, context|
     #       original = io.download
+    #       pipeline = ImageProcessing::MiniMagick.source(original)
+    #
+    #       size_800 = pipeline.resize_to_limit!(800, 800)
+    #       size_500 = pipeline.resize_to_limit!(500, 500)
+    #       size_300 = pipeline.resize_to_limit!(300, 300)
     #
-    #       size_800 = resize_to_limit!(original, 800, 800) { |cmd| cmd.auto_orient }
-    #       size_500 = resize_to_limit(size_800,  500, 500)
-    #       size_300 = resize_to_limit(size_500,  300, 300)
+    #       original.close!
     #
-    #       {large: size_800, medium: size_500, small: size_300}
+    #       { original: io, large: size_800, medium: size_500, small: size_300}
     #     end
     #
     # You probably want to load the `delete_raw` plugin to automatically
@@ -31,6 +35,7 @@ class Shrine
     #
     #     user.avatar_data #=>
     #     # '{
+    #     #   "original": {"id":"0gsdf.jpg", "storage":"store", "metadata":{...}},
     #     #   "large": {"id":"lg043.jpg", "storage":"store", "metadata":{...}},
     #     #   "medium": {"id":"kd9fk.jpg", "storage":"store", "metadata":{...}},
     #     #   "small": {"id":"932fl.jpg", "storage":"store", "metadata":{...}}
@@ -38,9 +43,10 @@ class Shrine
     #
     #     user.avatar #=>
     #     # {
-    #     #   :large =>  #<Shrine::UploadedFile @data={"id"=>"lg043.jpg", ...}>,
-    #     #   :medium => #<Shrine::UploadedFile @data={"id"=>"kd9fk.jpg", ...}>,
-    #     #   :small =>  #<Shrine::UploadedFile @data={"id"=>"932fl.jpg", ...}>,
+    #     #   :original => #<Shrine::UploadedFile @data={"id"=>"0gsdf.jpg", ...}>,
+    #     #   :large    => #<Shrine::UploadedFile @data={"id"=>"lg043.jpg", ...}>,
+    #     #   :medium   => #<Shrine::UploadedFile @data={"id"=>"kd9fk.jpg", ...}>,
+    #     #   :small    => #<Shrine::UploadedFile @data={"id"=>"932fl.jpg", ...}>,
     #     # }
     #
     #     user.avatar[:medium]     #=> #<Shrine::UploadedFile>
@@ -121,12 +127,13 @@ class Shrine
     #
     # ## Original file
     #
-    # If you want to keep the original file, you can include the original
-    # `Shrine::UploadedFile` object as one of the versions:
+    # It's recommended to always keep the original file after processing
+    # versions, which you can do by adding the yielded `Shrine::UploadedFile`
+    # object as one of the versions, by convention named `:original`:
     #
     #     process(:store) do |io, context|
     #       # processing thumbnail
-    #       {original: io, thumbnail: thumbnail}
+    #       { original: io, thumbnail: thumbnail }
     #     end
     #
     # If both temporary and permanent storage are Amazon S3, the cached original
@@ -147,6 +154,11 @@ class Shrine
     #       "/images/defaults/#{options[:version]}.jpg"
     #     end
     #
+    # ## Re-create Versions
+    #
+    # If you want to re-create a single or all versions, refer to the [reprocessing versions] guide for details.
+    #
+    # [reprocessing versions]: http://shrinerb.com/rdoc/files/doc/regenerating_versions_md.html
     # [image_processing]: https://github.com/janko-m/image_processing
     module Versions
       def self.load_dependencies(uploader, *)

data/lib/shrine/storage/file_system.rb

@@ -126,8 +126,10 @@ class Shrine
 
       # Copies the file into the given location.
       def upload(io, id, shrine_metadata: {}, **upload_options)
-        IO.copy_stream(io, path!(id))
+        bytes_copied = IO.copy_stream(io, path!(id))
         path(id).chmod(permissions) if permissions
+
+        shrine_metadata["size"] ||= bytes_copied
       end
 
       # Moves the file to the given location. This gets called by the `moving`

data/lib/shrine/storage/linter.rb

@@ -140,7 +140,7 @@ class Shrine
         end
 
         extend Forwardable
-        delegate Shrine::IO_METHODS.keys => :@io
+        delegate %i[read rewind eof? close size] => :@io
       end
     end
   end

data/lib/shrine/storage/s3.rb

@@ -15,9 +15,11 @@ rescue LoadError => exception
     raise exception
   end
 end
+
 require "down/chunked_io"
 require "uri"
 require "cgi"
+require "tempfile"
 
 class Shrine
   module Storage
@@ -172,6 +174,8 @@ class Shrine
     # [Transfer Acceleration]: http://docs.aws.amazon.com/AmazonS3/latest/dev/transfer-acceleration.html
     # [object lifecycle]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html#put-instance_method
     class S3
+      MIN_PART_SIZE = 5 * 1024 * 1024 # 5MB
+
       attr_reader :client, :bucket, :prefix, :host, :upload_options
 
       # Initializes a storage for uploading to S3.
@@ -248,11 +252,12 @@ class Shrine
         if copyable?(io)
           copy(io, id, **options)
         else
-          put(io, id, **options)
+          bytes_uploaded = put(io, id, **options)
+          shrine_metadata["size"] ||= bytes_uploaded
         end
       end
 
-      # Downloads the file from S3, and returns a `Tempfile`. And additional
+      # Downloads the file from S3, and returns a `Tempfile`. Any additional
       # options are forwarded to [`Aws::S3::Object#get`].
       #
       # [`Aws::S3::Object#get`]: http://docs.aws.amazon.com/sdk-for-ruby/v3/api/Aws/S3/Object.html#get-instance_method
@@ -396,11 +401,25 @@ class Shrine
           # use `upload_file` for files because it can do multipart upload
           options = { multipart_threshold: @multipart_threshold[:upload] }.merge!(options)
           object(id).upload_file(path, **options)
+          File.size(path)
         else
-          object(id).put(body: io, **options)
+          io.open if io.is_a?(UploadedFile)
+
+          if io.respond_to?(:size) && io.size
+            object(id).put(body: io, **options)
+            io.size
+          else
+            # IO has unknown size, so we have to use multipart upload
+            multipart_put(io, id, **options)
+          end
         end
       end
 
+      # Uploads the file to S3 using multipart upload.
+      def multipart_put(io, id, **options)
+        MultipartUploader.new(object(id)).upload(io, **options)
+      end
+
       # The file is copyable if it's on S3 and on the same Amazon account.
       def copyable?(io)
         io.is_a?(UploadedFile) &&
@@ -425,6 +444,53 @@ class Shrine
           CGI.escape(filename).gsub("+", " ")
         end
       end
+
+      # Uploads IO objects of unknown size using the multipart API.
+      class MultipartUploader
+        def initialize(object)
+          @object = object
+        end
+
+        # Initiates multipart upload, uploads IO content into multiple parts,
+        # and completes the multipart upload. If an exception is raised, the
+        # multipart upload is automatically aborted.
+        def upload(io, **options)
+          multipart_upload = @object.initiate_multipart_upload(**options)
+
+          parts = upload_parts(multipart_upload, io)
+          bytes_uploaded = parts.inject(0) { |size, part| size + part.delete(:size) }
+
+          multipart_upload.complete(multipart_upload: { parts: parts })
+
+          bytes_uploaded
+        rescue
+          multipart_upload.abort if multipart_upload
+          raise
+        end
+
+        # Uploads parts until the IO object has reached EOF.
+        def upload_parts(multipart_upload, io)
+          1.step.inject([]) do |parts, part_number|
+            parts << upload_part(multipart_upload, io, part_number)
+            break parts if io.eof?
+            parts
+          end
+        end
+
+        # Uploads at most 5MB of IO content into a single multipart part.
+        def upload_part(multipart_upload, io, part_number)
+          Tempfile.create("shrine-s3-part-#{part_number}") do |body|
+            multipart_part = multipart_upload.part(part_number)
+
+            IO.copy_stream(io, body, MIN_PART_SIZE)
+            body.rewind
+
+            response = multipart_part.upload(body: body)
+
+            { part_number: part_number, size: body.size, etag: response.etag }
+          end
+        end
+      end
     end
   end
 end

data/lib/shrine/version.rb

@@ -7,7 +7,7 @@ class Shrine
 
   module VERSION
     MAJOR = 2
-    MINOR = 9
+    MINOR = 10
     TINY  = 0
     PRE   = nil
 

data/shrine.gemspec

@@ -18,7 +18,7 @@ tying them to record's lifecycle. It natively supports background jobs and
 direct uploads for fully asynchronous user experience.
   END
 
-  gem.homepage     = "https://github.com/janko-m/shrine"
+  gem.homepage     = "https://github.com/shrinerb/shrine"
   gem.authors      = ["Janko Marohnić"]
   gem.email        = ["janko.marohnic@gmail.com"]
   gem.license      = "MIT"
@@ -42,6 +42,8 @@ direct uploads for fully asynchronous user experience.
   gem.add_development_dependency "mime-types"
   gem.add_development_dependency "mini_mime", "~> 1.0"
   gem.add_development_dependency "fastimage"
+  gem.add_development_dependency "mini_magick", "~> 4.0"
+  gem.add_development_dependency "ruby-vips", "~> 2.0"
   gem.add_development_dependency "aws-sdk-s3", "~> 1.2"
 
   unless RUBY_ENGINE == "jruby" || ENV["CI"]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shrine
 version: !ruby/object:Gem::Version
-  version: 2.9.0
+  version: 2.10.0
 platform: ruby
 authors:
 - Janko Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-27 00:00:00.000000000 Z
+date: 2018-03-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: down
@@ -206,6 +206,34 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: mini_magick
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: ruby-vips
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
 - !ruby/object:Gem::Dependency
   name: aws-sdk-s3
   requirement: !ruby/object:Gem::Requirement
@@ -361,7 +389,7 @@ files:
 - lib/shrine/storage/s3.rb
 - lib/shrine/version.rb
 - shrine.gemspec
-homepage: https://github.com/janko-m/shrine
+homepage: https://github.com/shrinerb/shrine
 licenses:
 - MIT
 metadata: {}