shrine 3.0.1 → 3.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0b327565465d4140206d1f88433647e7959b6c56ecbdea7d433f1aa5eb01825d
-  data.tar.gz: c19fb7f15299b1d061325f8f83e790f44481456fbc9730d4a909923193dde1a3
+  metadata.gz: 30bd30989579217202b2c51b9a00abe778af7cbab75fc9df78052bc074ce9405
+  data.tar.gz: 5c718df903c203e06ea44afa9c9017fa2cf01a8924c99e86a87be52f52ce0233
 SHA512:
-  metadata.gz: 897bbe8787b3a1f7e59db3e6beebbc91b32ec5e4c19cd832029e05205425c12d837bf8475f21949c23a6c805504da45a0937de0d3dc9f50d3d35921b5f6a7901
-  data.tar.gz: 995b0ada0e5bdb2c4e198304d913f6cfe22d8814328d58bf559490ea572ac3d5555f3eb15fce898ae423ff54f76ba3bcbbeb7f6e05470ddca8acee37ee675455
+  metadata.gz: 27f896211caba27686d5988750ce214ec0b31e70e9bbcf8a7d325952a5eee2e4c3293d539bb3074d4384964723bda09edd1acfcdcd387d82a4ef7373ff5787f0
+  data.tar.gz: 3d06d57d2eb1fee1cada71dfa4092a23c4b0bf4d5df8cf76e2fbf2eb4eaf5c9477f333ef241772d917456ebfb3067ad0ce7adc6becc49e15c9129720842cd5b3

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+## 3.1.0 (2019-11-15) [[release notes]](https://shrinerb.com/docs/release_notes/3.1.0)
+
+* `default_storage` – Coerce storage key to symbol in `Attacher#cache_key` & `Attacher#store_key` (@janko)
+
+* `core` – Coerce storage key to symbol in `Attacher#cache_key` & `Attacher#store_key` (@janko)
+
+* `add_metadata` – Define metadata methods only for the target uploader class (@janko)
+
+* `derivatives` – Add `:storage` option to `Attacher#create_derivatives` (@janko)
+
+* `store_dimensions` – Propagate exceptions on loading `ruby-vips` in `:vips` analyzer (@janko)
+
+* `signature` – Allow skipping rewinding by passing `rewind: false` to `Shrine.signature` (@janko)
+
+* `derivatives` – Add `Attacher.derivatives` alias for `Attacher.derivatives_processor` (@janko)
+
 ## 3.0.1 (2019-10-17) [[release notes]](https://shrinerb.com/docs/release_notes/3.0.1)
 
 * `metadata_attributes` – Fix exception being raised when there is no attached file (@janko)

data/LICENSE.txt

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2015-2017 Janko Marohnić
+Copyright (c) 2015-2019 Janko Marohnić
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,5 +1,7 @@
 # [Shrine]
 
+<img src="https://shrinerb.com/img/logo.png" width="100" alt="Shrine logo: a red paperclip" align="right" />
+
 Shrine is a toolkit for handling file attachments in Ruby applications. Some highlights:
 
 * **Modular design** – the [plugin system] allows you to load only the functionality you need
@@ -12,7 +14,9 @@ Shrine is a toolkit for handling file attachments in Ruby applications. Some hig
 * **Resumable uploads** – make large file uploads [resumable][resumable upload] on [S3][uppy-s3_multipart] or [tus][tus-ruby-server]
 * **Background jobs** – built-in support for [background processing][backgrounding] that supports [any backgrounding library][Backgrounding Libraries]
 
-Please follow along with the **[Getting Started guide]**.
+If you're curious how it compares to other file attachment libraries, see the
+[Advantages of Shrine]. Otherwise, follow along with the **[Getting Started
+guide]**.
 
 ## Links
 
@@ -52,7 +56,7 @@ Shrine.plugin :restore_cached_data    # extracts metadata for assigned cached fi
 Next, add the `<name>_data` column to the table you want to attach files to. For
 an "image" attachment on a `photos` table this would be an `image_data` column:
 
-```sh
+```
 $ rails generate migration add_image_data_to_photos image_data:text
 ```
 
@@ -133,6 +137,7 @@ mailing lists is expected to follow the [Shrine code of conduct][CoC].
 The gem is available as open source under the terms of the [MIT License].
 
 [Shrine]: https://shrinerb.com
+[Advantages of Shrine]: https://shrinerb.com/docs/advantages
 [plugin system]: https://shrinerb.com/docs/getting-started#plugin-system
 [Retrieving Uploads]: https://shrinerb.com/docs/retrieving-uploads
 [FileSystem]: https://shrinerb.com/docs/storage/file-system

data/doc/advantages.md

@@ -171,7 +171,7 @@ thumbnails during attachment:
 
 ```rb
 class ImageUploader < Shrine
-  Attacher.derivatives_processor do |original|
+  Attacher.derivatives do |original|
     magick = ImageProcessing::MiniMagick.source(original)
 
     {
@@ -261,7 +261,7 @@ gem "streamio-ffmpeg"
 ```
 ```rb
 class VideoUploader < Shrine
-  Attacher.derivatives_processor do |original|
+  Attacher.derivatives do |original|
     transcoded = Tempfile.new ["transcoded", ".mp4"]
     screenshot = Tempfile.new ["screenshot", ".jpg"]
 
@@ -281,7 +281,7 @@ movie.video(:transcoded) #=> #<Shrine::UploadedFile id="7481d6.mp4" ...>
 movie.video(:screenshot) #=> #<Shrine::UploadedFile id="8f3136.jpg" ...>
 ```
 
-## Metadata & Validation
+## Metadata
 
 Shrine automatically [extracts metadata][metadata] from each uploaded file,
 including derivatives like image thumbnails, and saves them into the database
@@ -289,6 +289,17 @@ column. In addition to filename, filesize, and MIME type that are extracted by
 default, you can also extract [image dimensions][store_dimensions], or your own
 [custom metadata][add_metadata].
 
+```rb
+class ImageUploader < Shrine
+  plugin :determine_mime_type # mime_type
+  plugin :store_dimensions    # width & height
+
+  add_metadata :resolution do |io|
+    image = MiniMagick::Image.new(io.path)
+    image.resolution
+  end
+end
+```
 ```rb
 photo.image.metadata #=>
 # {
@@ -297,23 +308,30 @@ photo.image.metadata #=>
 #   "mime_type" => "image/jpeg",
 #   "width" => 600,
 #   "height" => 400,
+#   "resolution" => [72, 72],
 #   ...
 # }
 ```
 
-For common metadata you can use the built-in [validators][validation_helpers],
-but you can also [validate any custom metadata][custom validations].
+## Validation
+
+For file validations there are [built-in validators][validation_helpers], but
+you can also just use plain Ruby code:
 
 ```rb
-class DocumentUploader < Shrine
+class ImageUploader < Shrine
+  plugin :validation_helpers
+
   Attacher.validate do
-    # validation macros
     validate_max_size 10*1024*1024
-    validate_mime_type %W[application/pdf]
+    validate_extension %w[jpg jpeg png webp]
+
+    if validate_mime_type %W[image/jpeg image/png image/webp]
+      validate_max_dimensions [5000, 5000]
 
-    # custom validations
-    if file["page_count"] > 30
-      errors << "must not have more than 30 pages"
+      unless ImageProcessing::MiniMagick.valid_image?(file.download.path)
+        error << "seems to be corrupted"
+      end
     end
   end
 end
@@ -432,7 +450,6 @@ on top of Rack, so that they can be used with any Ruby web framework.
 [backgrounding libraries]: https://github.com/shrinerb/shrine/wiki/Backgrounding-Libraries
 [Down streaming]: https://github.com/janko/down#streaming
 [validation_helpers]: https://shrinerb.com/docs/plugins/validation_helpers
-[custom validations]: https://shrinerb.com/docs/validation#custom-validations
 [derivatives]: https://shrinerb.com/docs/plugins/derivatives
 [derivation_endpoint]: https://shrinerb.com/docs/plugins/derivation_endpoint
 [libvips performance]: https://github.com/libvips/libvips/wiki/Speed-and-memory-use#results

data/doc/carrierwave.md

@@ -6,7 +6,7 @@ This guide is aimed at helping CarrierWave users transition to Shrine, and it
 consists of three parts:
 
 1. Explanation of the key differences in design between CarrierWave and Shrine
-2. Instructions how to migrate and existing app that uses CarrierWave to Shrine
+2. Instructions how to migrate an existing app that uses CarrierWave to Shrine
 3. Extensive reference of CarrierWave's interface with Shrine equivalents
 
 ## Overview
@@ -159,7 +159,7 @@ require "image_processing/mini_magick"
 class ImageUploader < Shrine
   plugin :derivatives
 
-  Attacher.derivatives_processor do |original|
+  Attacher.derivatives do |original|
     magick = ImageProcessing::MiniMagick.source(original)
 
     {
@@ -268,18 +268,24 @@ Files] guide explains this setup in more detail.
 ## Migrating from CarrierWave
 
 You have an existing app using CarrierWave and you want to transfer it to
-Shrine. Let's assume we have a `Photo` model with the "image" attachment. First
-we need to create the `image_data` column for Shrine:
+Shrine. Let's assume we have a `Photo` model with the "image" attachment.
+
+### 1. Add Shrine column
+
+First we need to create the `image_data` column for Shrine:
 
 ```rb
 add_column :photos, :image_data, :text # or :json or :jsonb if supported
 ```
 
-Afterwards we need to make new uploads write to the `image_data` column. This
-can be done by including the below module to all models that have CarrierWave
-attachments:
+### 2. Dual write
+
+Next, we need to make new CarrierWave attachments write to the
+`image_data` column. This can be done by including the below module to all
+models that have CarrierWave attachments:
 
 ```rb
+# config/initializers/shrine.rb (Rails)
 require "shrine"
 
 Shrine.storages = {
@@ -289,8 +295,7 @@ Shrine.storages = {
 
 Shrine.plugin :model
 Shrine.plugin :derivatives
-```
-```rb
+
 module CarrierwaveShrineSynchronization
   def self.included(model)
     model.before_save do
@@ -302,13 +307,13 @@ module CarrierwaveShrineSynchronization
 
   def write_shrine_data(name)
     uploader = send(name)
-    attacher = Shrine::Attacher.form_model(self, name)
+    attacher = Shrine::Attacher.from_model(self, name)
 
     if read_attribute(name).present?
       attacher.set shrine_file(uploader)
 
-      uploader.versions.each do |name, version|
-        attacher.merge_derivatives(name => shrine_file(version))
+      uploader.versions.each do |version_name, version|
+        attacher.merge_derivatives(version_name => shrine_file(version))
       end
     else
       attacher.set nil
@@ -340,20 +345,27 @@ end
 ```
 
 After you deploy this code, the `image_data` column should now be successfully
-synchronized with new attachments.  Next step is to run a script which writes
-all existing CarrierWave attachments to `image_data`:
+synchronized with new attachments.
+
+### 3. Data migration
+
+Next step is to run a script which writes all existing CarrierWave attachments
+to `image_data`:
 
 ```rb
 Photo.find_each do |photo|
-  Photo.uploaders.each_key { |name| photo.write_shrine_data(name) }
+  photo.write_shrine_data(:image)
   photo.save!
 end
 ```
 
+### 4. Rewrite code
+
 Now you should be able to rewrite your application so that it uses Shrine
-instead of CarrierWave, using equivalent Shrine storages. For help with
-translating the code from CarrierWave to Shrine, you can consult the reference
-below.
+instead of CarrierWave (you can consult the reference in the next section). You
+can remove the `CarrierwaveShrineSynchronization` module as well.
+
+### 5. Backill metadata
 
 You'll notice that Shrine metadata will be absent from the migrated files'
 data. You can run a script that will fill in any missing metadata defined in
@@ -363,11 +375,20 @@ your Shrine uploader:
 Shrine.plugin :refresh_metadata
 
 Photo.find_each do |photo|
-  photo.image_attacher.refresh_metadata!
-  photo.save
+  attacher = photo.image_attacher
+  attacher.refresh_metadata!
+  attacher.atomic_persist
 end
 ```
 
+### 6. Remove CarrierWave column
+
+If everything is looking good, we can remove the CarrierWave column:
+
+```rb
+remove_column :photos, :image
+```
+
 ## CarrierWave to Shrine direct mapping
 
 ### `CarrierWave::Uploader::Base`
@@ -395,7 +416,7 @@ Processing is defined by using the `derivatives` plugin:
 class ImageUploader < Shrine
   plugin :derivatives
 
-  Attacher.derivatives_processor do |original|
+  Attacher.derivatives do |original|
     magick = ImageProcessing::MiniMagick.source(image)
 
     {
@@ -499,7 +520,7 @@ class ImageUploader < Shrine
 end
 ```
 
-#### `#blacklist_mime_type_pattern`, `#whitelist_mime_type_pattern`, `#content_type_whitelist`, `#content_type_blacklist`
+####  `#content_type_whitelist`, `#content_type_blacklist`
 
 In Shrine, MIME type whitelisting/blacklisting is part of validations, and is
 provided by the `validation_helpers` plugin, though it doesn't support regexes:
@@ -515,6 +536,17 @@ class ImageUploader < Shrine
 end
 ```
 
+Make sure to also load the `determine_mime_type` plugin to detect MIME type
+from file content.
+
+```rb
+# Gemfile
+gem "mimemagic"
+```
+```rb
+Shrine.plugin :determine_mime_type, analyzer: :mimemagic
+```
+
 #### `#size_range`
 
 In Shrine file size validations are typically done using the

data/doc/changing_derivatives.md

@@ -42,7 +42,7 @@ gem "image_processing", "~> 1.8"
 require "image_processing/mini_magick"
 
 class ImageUploader < Shrine
-  Attacher.derivatives_processor do |original|
+  Attacher.derivatives do |original|
     magick = ImageProcessing::MiniMagick.source(original)
 
     # generate the thumbnails you want here
@@ -93,16 +93,16 @@ now you want to reprocess them for existing attachments.*
 Let's assume we've made the following change and have deployed it to production:
 
 ```diff
-Attacher.derivatives_processor do |original|
-  magick = ImageProcessing::MiniMagick.source(original)
+ Attacher.derivatives do |original|
+   magick = ImageProcessing::MiniMagick.source(original)
 +   .saver(quality: 85)
 
-  {
-    small:  magick.resize_to_limit!(300, 300),
-    medium: magick.resize_to_limit!(500, 500),
-    large:  magick.resize_to_limit!(800, 800),
-  }
-end
+   {
+     small:  magick.resize_to_limit!(300, 300),
+     medium: magick.resize_to_limit!(500, 500),
+     large:  magick.resize_to_limit!(800, 800),
+   }
+ end
 ```
 
 We can now run the following script to reprocess derivatives for all existing
@@ -139,16 +139,16 @@ you want to reprocess them for existing attachments.*
 Let's assume we've made a following change and have deployed it to production:
 
 ```diff
-Attacher.derivatives_processor do |original|
-  magick = ImageProcessing::MiniMagick.source(original)
-
-  {
-    small:  magick.resize_to_limit!(300, 300),
--   medium: magick.resize_to_limit!(500, 500),
-+   medium: magick.resize_to_limit!(600, 600),
-    large:  magick.resize_to_limit!(800, 800),
-  }
-end
+ Attacher.derivatives do |original|
+   magick = ImageProcessing::MiniMagick.source(original)
+
+   {
+     small:  magick.resize_to_limit!(300, 300),
+-    medium: magick.resize_to_limit!(500, 500),
++    medium: magick.resize_to_limit!(600, 600),
+     large:  magick.resize_to_limit!(800, 800),
+   }
+ end
 ```
 
 We can now run the following script to reprocess the derivative for all
@@ -189,16 +189,16 @@ you want to add it to existing attachments.*
 Let's assume we've made a following change and have deployed it to production:
 
 ```diff
-Attacher.derivatives_processor do |original|
-  magick = ImageProcessing::MiniMagick.source(original)
-
-  {
-+   square: magick.resize_to_fill!(150, 150),
-    small:  magick.resize_to_limit!(300, 300),
-    medium: magick.resize_to_limit!(600, 600),
-    large:  magick.resize_to_limit!(800, 800),
-  }
-end
+ Attacher.derivatives do |original|
+   magick = ImageProcessing::MiniMagick.source(original)
+
+   {
++    square: magick.resize_to_fill!(150, 150),
+     small:  magick.resize_to_limit!(300, 300),
+     medium: magick.resize_to_limit!(600, 600),
+     large:  magick.resize_to_limit!(800, 800),
+   }
+ end
 ```
 
 We can now run following script to add the new derivative for all existing
@@ -239,16 +239,16 @@ existing attachments.*
 Let's assume we've made the following change and have deployed it to production:
 
 ```diff
-Attacher.derivatives_processor do |original|
-  magick = ImageProcessing::MiniMagick.source(original)
-
-  {
--   square: magick.resize_to_fill!(150, 150),
-    small:  magick.resize_to_limit!(300, 300),
-    medium: magick.resize_to_limit!(600, 600),
-    large:  magick.resize_to_limit!(800, 800),
-  }
-end
+ Attacher.derivatives do |original|
+   magick = ImageProcessing::MiniMagick.source(original)
+
+   {
+-    square: magick.resize_to_fill!(150, 150),
+     small:  magick.resize_to_limit!(300, 300),
+     medium: magick.resize_to_limit!(600, 600),
+     large:  magick.resize_to_limit!(800, 800),
+   }
+ end
 ```
 
 We can now run following script to remove the unused derivative for all

data/doc/getting_started.md

@@ -50,7 +50,7 @@ class AddImageDataToPhotos < ActiveRecord::Migration
 end
 ```
 <!--Rails-->
-```sh
+```
 $ rails generate migration add_image_data_to_photos image_data:text
 ```
 <!--END_DOCUSAURUS_CODE_TABS-->
@@ -186,8 +186,8 @@ s3_options = {
 }
 
 Shrine.storages = {
-  cache: Shrine::Storage::S3.new(prefix: "cache", **s3_options),
-  store: Shrine::Storage::S3.new(**s3_options),
+  cache: Shrine::Storage::S3.new(prefix: "cache", **s3_options), # temporary
+  store: Shrine::Storage::S3.new(**s3_options),                  # permanent
 }
 ```
 
@@ -254,15 +254,17 @@ uploader.upload(io, upload_options: { acl: "public-read" }) # add options to Sto
 
 Shrine is able to upload any IO-like object that implement methods [`#read`],
 [`#rewind`], [`#eof?`] and [`#close`] whose behaviour matches the [`IO`] class.
-This includes built-in IO and IO-like objects like File, Tempfile and StringIO.
+This includes but is not limited to the following objects:
 
-When a file is uploaded to a Rails app, in request params it will be
-represented by an `ActionDispatch::Http::UploadedFile` object, which is also an
-IO-like object accepted by Shrine. In other Rack applications the uploaded file
-will be represented as a Hash, but it can be converted into an IO-like object
-with the [`rack_file`][rack_file plugin] plugin.
-
-Here are some examples of various IO-like objects that can be uploaded:
+* `File`
+* `Tempfile`
+* `StringIO`
+* `ActionDispatch::Http::UploadedFile` (Rails form upload)
+* `Shrine::RackFile` ([`rack_file`][rack_file plugin] plugin)
+* `Shrine::DataFile` ([`data_uri`][data_uri plugin] plugin)
+* `Shrine::UploadedFile`
+* `Down::ChunkedIO` ([Down] gem)
+* ...
 
 ```rb
 uploader.upload File.open("/path/to/file", binmode: true)   # upload from disk
@@ -278,7 +280,15 @@ uploader.upload Shrine::UploadedFile.new(...)               # upload from Shrine
 
 The `Shrine::UploadedFile` object represents the file that was uploaded to a
 storage, and it's what's returned from `Shrine#upload` or when retrieving a
-record [attachment]. It contains the following data:
+record [attachment].
+
+```rb
+uploader.upload(file) #=> #<Shrine::UploadedFile ...>  (uploader)
+photo.image           #=> #<Shrine::UploadedFile ...>  (attachment)
+attacher.file         #=> #<Shrine::UploadedFile ...>  (attacher)
+```
+
+An uploaded file object contains the following data:
 
 | Key        | Description                                        |
 | :-------   | :----------                                        |
@@ -287,13 +297,12 @@ record [attachment]. It contains the following data:
 | `metadata` | file [metadata] that was extracted before upload   |
 
 ```rb
-uploaded_file = uploader.upload(file)
 uploaded_file #=> #<Shrine::UploadedFile id="949sdjg834.jpg" storage=:store metadata={...}>
 
-uploaded_file.id          # => "949sdjg834.jpg"
-uploaded_file.storage_key # => :store
-uploaded_file.storage     # => #<Shrine::Storage::S3>
-uploaded_file.metadata    # => {...}
+uploaded_file.id          #=> "949sdjg834.jpg"
+uploaded_file.storage_key #=> :store
+uploaded_file.storage     #=> #<Shrine::Storage::S3>
+uploaded_file.metadata    #=> {...}
 ```
 
 It comes with many convenient methods that delegate to the storage:
@@ -341,7 +350,7 @@ The easiest way to attach files is with the `Shrine::Attachment` module:
 ```rb
 class Photo < Sequel::Model # ActiveRecord::Base
   include ImageUploader::Attachment.new(:image) #
-  include ImageUploader::Attachment[:image]     # use a preferred syntax
+  include ImageUploader::Attachment[:image]     # use your preferred syntax
   include ImageUploader::Attachment(:image)     #
 end
 ```
@@ -364,7 +373,7 @@ that attachments are deleted when the record is destroyed.
 photo.image #=> nil
 
 # the assigned file is cached to temporary storage and written to `image_data` column
-photo.image = File.open("waterfall.jpg")
+photo.image = File.open("waterfall.jpg", "rb")
 photo.image      #=> #<Shrine::UploadedFile ...>
 photo.image_url  #=> "/uploads/cache/0sdfllasfi842.jpg"
 photo.image_data #=> '{"id":"0sdfllasfi842.jpg","storage":"cache","metadata":{...}}'
@@ -408,12 +417,10 @@ attacher.url          # equivalent to `photo.image_url`
 ```
 
 The attacher is what drives attaching files to model instances; you can use it
-as a more explicit alternative to models' attachment interface, or simply when
-you need something that's not available through the attachment methods.
+as a more explicit alternative to models' attachment interface, or when you
+need something that's not available through the attachment methods.
 
-You can do things such as change the temporary and permanent storage the
-attacher uses, or upload files directly to permanent storage. See the [Using
-Attacher] guide for more details.
+See [Using Attacher] guide for more details.
 
 ### Temporary storage
 
@@ -424,18 +431,18 @@ files go straight to permanent storage:
 ```rb
 Shrine.plugin :model, cache: false
 ```
-<!--DOCUSAURUS_CODE_TABS-->
-<!--Attachment-->
 ```rb
-photo.image = File.open("waterfall.jpg")
+photo.image = File.open("waterfall.jpg", "rb")
 photo.image.storage_key #=> :store
 ```
-<!--Attacher-->
+
+If you're using the attacher directly, you can just use `Attacher#attach`
+instead of `Attacher#assign`:
+
 ```rb
-attacher.attach File.open("waterfall.jpg")
+attacher.attach File.open("waterfall.jpg", "rb")
 attacher.file.storage_key #=> :store
 ```
-<!--END_DOCUSAURUS_CODE_TABS-->
 
 ## Plugin system
 
@@ -519,7 +526,7 @@ For image processing, it's recommended to use the **[ImageProcessing]** gem,
 which is a high-level wrapper for processing with
 [MiniMagick][ImageProcessing::MiniMagick] and [libvips][ImageProcessing::Vips].
 
-```sh
+```
 $ brew install imagemagick vips
 ```
 
@@ -539,7 +546,7 @@ Shrine.plugin :derivatives
 require "image_processing/mini_magick"
 
 class ImageUploader < Shrine
-  Attacher.derivatives_processor do |original|
+  Attacher.derivatives do |original|
     magick = ImageProcessing::MiniMagick.source(original)
 
     {
@@ -580,12 +587,9 @@ documentation and the [File Processing] guide.
 ### Processing on-the-fly
 
 On-the-fly processing is provided by the
-[`derivation_endpoint`][derivation_endpoint plugin] plugin. It comes with a
-[mountable][Mounting Endpoints] Rack app which applies processing on request
-and returns processed files.
-
-To set it up, we mount the Rack app in our router on a chosen path prefix,
-configure the plugin with a secret key and that path prefix, and define
+[`derivation_endpoint`][derivation_endpoint plugin] plugin. To set it up, we
+configure the plugin with a secret key and a path prefix, [mount][Mounting
+Endpoints] its Rack app in our routes on the configured path prefix, and define
 processing we want to perform:
 
 ```rb
@@ -593,25 +597,24 @@ processing we want to perform:
 gem "image_processing", "~> 1.8"
 ```
 ```rb
-# config/routes.rb (Rails)
-Rails.application.routes.draw do
-  # ...
-  mount ImageUploader.derivation_endpoint => "/derivations/image"
+# config/initializers/shrine.rb (Rails)
+require "image_processing/mini_magick"
+
+Shrine.plugin :derivation_endpoint,
+  secret_key: "<YOUR SECRET KEY>",
+  prefix:     "derivations" # needs to match the mount point in routes
+
+Shrine.derivation :thumbnail do |file, width, height|
+  ImageProcessing::MiniMagick
+    .source(file)
+    .resize_to_limit!(width.to_i, height.to_i)
 end
 ```
 ```rb
-require "image_processing/mini_magick"
-
-class ImageUploader < Shrine
-  plugin :derivation_endpoint,
-    secret_key: "<YOUR SECRET KEY>",
-    prefix:     "derivations/image" # needs to match the mount point in routes
-
-  derivation :thumbnail do |file, width, height|
-    ImageProcessing::MiniMagick
-      .source(file)
-      .resize_to_limit!(width.to_i, height.to_i)
-  end
+# config/routes.rb (Rails)
+Rails.application.routes.draw do
+  # ...
+  mount Shrine.derivation_endpoint => "/derivations"
 end
 ```
 
@@ -620,7 +623,7 @@ processing:
 
 ```rb
 photo.image.derivation_url(:thumbnail, 600, 400)
-#=> "/derivations/image/thumbnail/600/400/eyJpZCI6ImZvbyIsInN0b3JhZ2UiOiJzdG9yZSJ9?signature=..."
+#=> "/derivations/thumbnail/600/400/eyJpZCI6ImZvbyIsInN0b3JhZ2UiOiJzdG9yZSJ9?signature=..."
 ```
 
 The on-the-fly processing feature is highly customizable, see the
@@ -675,7 +678,7 @@ class ImageUploader < Shrine
   end
 end
 ```
-```plaintext
+```
 uploads/
   photos/
     originals/
@@ -906,7 +909,7 @@ uploaded_file.exists?
 uploaded_file.download
 uploaded_file.delete
 ```
-```plaintext
+```
 Metadata (32ms) – {:storage=>:store, :io=>StringIO, :uploader=>Shrine}
 Upload (1523ms) – {:storage=>:store, :location=>"ed0e30ddec8b97813f2c1f4cfd1700b4", :io=>StringIO, :upload_options=>{}, :uploader=>Shrine}
 Exists (755ms) – {:storage=>:store, :location=>"ed0e30ddec8b97813f2c1f4cfd1700b4", :uploader=>Shrine}
@@ -957,7 +960,7 @@ Shrine.logger.level = Logger::WARN
 [`Shrine::UploadedFile`]: https://shrinerb.com/rdoc/classes/Shrine/UploadedFile/InstanceMethods.html
 
 [attacher]: #attacher
-[attachment]: #attachment
+[attachment]: #attaching
 [backgrounding]: #backgrounding
 [direct uploads]: #direct-uploads
 [io abstraction]: #io-abstraction
@@ -1001,10 +1004,12 @@ Shrine.logger.level = Logger::WARN
 [ImageProcessing::MiniMagick]: https://github.com/janko/image_processing/blob/master/doc/minimagick.md#readme
 [ImageProcessing::Vips]: https://github.com/janko/image_processing/blob/master/doc/vips.md#readme
 [`file`]: http://linux.die.net/man/1/file
+[Down]: https://github.com/janko/down
 
 [activerecord plugin]: https://shrinerb.com/docs/plugins/activerecord
 [add_metadata plugin]: https://shrinerb.com/docs/plugins/add_metadata
 [backgrounding plugin]: https://shrinerb.com/docs/plugins/backgrounding
+[data_uri plugin]: https://shrinerb.com/docs/plugins/data_uri
 [derivation_endpoint plugin]: https://shrinerb.com/docs/plugins/derivation_endpoint
 [derivatives plugin]: https://shrinerb.com/docs/plugins/derivatives
 [determine_mime_type plugin]: https://shrinerb.com/docs/plugins/determine_mime_type