shrine 3.0.0.alpha → 3.0.0.beta

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 36715577aa30205e12419931f31b3dfad46e30e659372c88e5e926d536984dfc
-  data.tar.gz: fd74dd99deef2030ebc5c2935bccb15447e5a5eb9a916c8379e6d57db87bba23
+  metadata.gz: c5f2d3f6519d99e728cdfffe80783d0278f171bb6f8a850b4840d2d9fb92eda5
+  data.tar.gz: 28566d4950a3ad23cb657e699db8a0861283efb8709a7a70d6a20c83d8a5c0c7
 SHA512:
-  metadata.gz: 2fbc8cce3080e6728d04c59e6e56b2653b47df3c0d8dece92f62590cebcd5d30a54c9f7f31ba11ff6fcf6041190438ee20785075c7ca3dce6863ac77311ca69b
-  data.tar.gz: '038a34aade2923b6c5ce0f36d6d8897dc1ac7cc06b06a06dd46cbffc26cc57db0345ead5674562ac1d84a7a8825e49a8a536ce0321321d7edbf3f429795fa492'
+  metadata.gz: 0cc989a0037051dd2cc84785a7a0a6080667e450ae8f1e95c4204d4474f9fac98d97498f435c82aed20036963ca86425ccf31e3d07ea274e9113e3b79439bb16
+  data.tar.gz: 6f4e12336f30753d55b53337efd695a712c4971744bd012497f79418890b3ed910084e6af7fe57c5c05025f854f44ffbb969e5c0aa3cba4aa0d9b729d1225267

data/CHANGELOG.md

@@ -1,3 +1,37 @@
+## 3.0.0.beta (2019-08-29)
+
+* `atomic_helpers` – Rename `:data` argument to `:file` in `Attacher.retrieve` (@janko)
+
+* `atomic_helpers` – Add `Attacher#file_data` which returns only main file data without metadata (@janko)
+
+* `model` – Add `Attacher#set_model` for setting model without loading attachment (@janko)
+
+* `entity` – Add `Attacher#set_entity` for setting entity without loading attachment (@janko)
+
+* `core` – Define `#<name>_attacher` class method when including `Shrine::Attachment` (@janko)
+
+* `derivation_endpoint` – Send only `:derivation` in the instrumentation event payload (@janko)
+
+* `default_storage` – Add `Attacher.default_cache` and `Attacher.default_store` for settings (@janko)
+
+* `default_storage` – Deprecate `record` & `name` arguments to storage block (@janko)
+
+* `default_storage` – Evaluate storage block in context of `Attacher` instance (@janko)
+
+* Simplify persistence interface (@janko)
+
+* `upload_options` – Keep `Shrine#_upload` private (@janko)
+
+* `infer_extension` – Keep `Shrine#basic_location` private (@janko)
+
+* `model` – Add `#<name>_changed?` method to attachment module (@janko)
+
+* `core` – Make it easier for plugins to define entity and model attachment methods (@janko)
+
+* `derivatives` – Add `#<name>_derivatives!` module method which delegates to `#create_derivatives` (@janko)
+
+* `derivatives` – Change `#create_derivatives` to forward all arguments to `#process_derivatives` (@janko)
+
 ## 3.0.0.alpha (2019-08-19)
 
 * `form_assign` – Add new plugin for assigning attachment from form params without a form object (@janko)
@@ -96,8 +130,6 @@
 
 * `attacher_options` – Add new plugin for setting default attacher operation options (@janko)
 
-* `validation` – Add `Attacher#validate_options` for registering default validation options (@janko)
-
 * `validation` – Allow skipping validations on attaching by passing `validate: false` (@janko)
 
 * `validation` – Add `:validate` option to `Attacher#assign` or `Attacher#attach` for passing options to validation block (@janko)

data/README.md

@@ -240,7 +240,7 @@ particular storage.
 
 ```rb
 class MyUploader < Shrine
-  # image attachent logic
+  # image attachment logic
 end
 ```
 

data/doc/creating_persistence_plugins.md

@@ -71,96 +71,53 @@ end
 
 ## Attacher
 
-### Persistence
-
-It's recommended to implement an `Attacher#persist` method which persists
-the attached file to the record.
-
-```rb
-module Shrine::Plugins::Raptor
-  # ...
-  module AttacherMethods
-    # ...
-    def persist(...)
-      # persist attachment data
-    end
-    # ...
-  end
-  # ...
-end
-```
-
-This way other 3rd-party plugins can use `Attacher#persist` and know it will do
-the right thing regardless of which persistence plugin is used.
-
-### Atomic promotion & persistence
-
-When using [`backgrounding`][backgrounding] plugin, it's useful to be able to
-make promotion/persistence atomic. The [`atomic_helpers`][atomic_helpers]
-plugin provides the abstract interface, and in your persistence plugin you can
-provide wrappers.
+To help define persistence methods on the `Attacher` according to the
+convention, load the `_persistence` plugin as a dependency:
 
 ```rb
 module Shrine::Plugins::Raptor
   def self.load_dependencies(uploader, **)
     # ...
-    uploader.plugin :atomic_helpers
-  end
-  # ...
-  module AttacherMethods
-    # ...
-    def atomic_promote(...)
-      # call #abstract_atomic_promote from atomic_helpers plugin
-    end
-
-    def atomic_persist(...)
-      # call #abstract_atomic_persist from atomic_helpers plugin
-    end
-    # ...
+    uploader.plugin :_persistence, plugin: self
   end
   # ...
 end
 ```
 
-See the [`activerecord`][activerecord]/[`sequel`][sequel] plugin source code on
-how this integration should look like.
+This will define the following attacher methods:
 
-### With other persistence plugins
+* `Attacher#persist`
+* `Attacher#atomic_persist`
+* `Attacher#atomic_promote`
 
-It's recommended to prefix each of the above methods with the name of the
-database library, and make non-prefixed versions aliases.
+For those methods to work, we'll need to implement the following methods:
+
+* `Attacher#<library>_persist`
+* `Attacher#<library>_reload`
+* `Attacher#<library>?`
 
 ```rb
 module Shrine::Plugins::Raptor
   # ...
   module AttacherMethods
     # ...
-    def raptor_atomic_promote(...)
-      # ...
+    private
+
+    def raptor_persist
+      # persist attached file to the record
     end
-    alias atomic_promote raptor_atomic_promote
 
-    def raptor_atomic_persist(...)
-      # ...
+    def raptor_reload
+      # yield reloaded record (see atomic_helpers plugin)
     end
-    alias atomic_persist raptor_atomic_persist
 
-    def raptor_persist(...)
-      # ...
+    def raptor?
+      # returns whether current model/entity belongs to Raptor
     end
-    alias persist raptor_persist
-    # ...
   end
-  # ...
 end
 ```
 
-That way the user can always specify from which persistence plugin they're
-calling a certain method, even when multiple persistence plugins are loaded
-simultaneously. The latter can be the case if the user is using multiple
-database libraries in a single application, or if they're transitioning from
-one library to another.
-
 [Writing a Plugin]: /doc/creating_plugins.md#readme
 [Active Record pattern]: https://www.martinfowler.com/eaaCatalog/activeRecord.html
 [model]: /doc/plugins/model.md#readme

data/doc/plugins/activerecord.md

@@ -21,7 +21,7 @@ end
 
 ### Callbacks
 
-#### Save
+#### After Save
 
 After a record is saved and the transaction is committed, `Attacher#finalize`
 is called, which promotes cached file to permanent storage and deletes previous
@@ -37,7 +37,7 @@ photo.save
 photo.image.storage_key #=> :store
 ```
 
-#### Destroy
+#### After Destroy
 
 After a record is destroyed and the transaction is committed,
 `Attacher#destroy_attached` method is called, which deletes stored attached
@@ -67,7 +67,7 @@ Active Record also currently has a [bug with transaction callbacks], so if
 you have any "after commit" callbacks, make sure to include Shrine's attachment
 module *after* they have all been defined.
 
-#### Skipping
+#### Skipping Callbacks
 
 If you don't want the attachment module to add any callbacks to your Active
 Record model, you can set `:callbacks` to `false`:
@@ -97,7 +97,7 @@ photo.valid?
 photo.errors #=> { image: ["size must not be greater than 10.0 MB"] }
 ```
 
-#### Presence
+#### Attachment Presence
 
 If you want to validate presence of the attachment, you can use Active Record's
 presence validator:
@@ -136,7 +136,7 @@ en:
               not_image: "must be a common image format"
 ```
 
-#### Skipping
+#### Skipping Validations
 
 If don't want the attachment module to merge file validations errors into
 model errors, you can set `:validations` to `false`:
@@ -150,107 +150,15 @@ plugin :activerecord, validations: false
 This section will cover methods added to the `Shrine::Attacher` instance. If
 you're not familar with how to obtain it, see the [`model`][model] plugin docs.
 
-### Atomic promotion
+The following persistence methods are added to the attacher:
 
-If you're promoting cached file to permanent storage
-[asynchronously][backgrounding], you might want to handle the possibility of
-the attachment changing during promotion. You can do that with
-`Attacher#atomic_promote`:
+| Method                    | Description                                                            |
+| :-----                    | :----------                                                            |
+| `Attacher#atomic_promote` | calls `Attacher#promote` and persists if the attachment hasn't changed |
+| `Attacher#atomic_persist` | saves changes if the attachment hasn't changed                         |
+| `Attacher#persist`        | saves any changes to the underlying record                             |
 
-```rb
-# in your controller
-attacher.attach_cached(io)
-attacher.cached? #=> true
-```
-```rb
-# in a background job
-attacher.atomic_promote # promotes cached file and persists
-attacher.stored? #=> true
-```
-
-After cached file is uploaded to permanent storage, the record is reloaded in
-order to check whether the attachment hasn't changed, and if it hasn't the
-attachment is persisted. If the attachment has changed,
-`Shrine::AttachmentChanged` exception is raised.
-
-Additional options are passed to `Attacher#promote`.
-
-#### Reloader & persister
-
-You can change how the record is reloaded or persisted during atomic promotion:
-
-```rb
-# reloader
-attacher.atomic_promote(reload: :lock)       # uses database locking (default)
-attacher.atomic_promote(reload: :fetch)      # reloads with no locking
-attacher.atomic_promote(reload: ->(&b){...}) # custom reloader (see atomic_helpers plugin docs)
-attacher.atomic_promote(reload: false)       # skips reloading
-
-# persister
-attacher.atomic_promote(persist: :save)   # persists stored file (default)
-attacher.atomic_promote(persist: ->{...}) # custom persister (see atomic_helpers plugin docs)
-attacher.atomic_promote(persist: false)   # skips persistence
-```
-
-For more details, see the [`atomic_helpers`][atomic_helpers] plugin docs.
-
-### Atomic persistence
-
-If you're updating something based on the attached file
-[asynchronously][backgrounding], you might want to handle the possibility of
-the attachment changing in the meanwhile. You can do that with
-`Attacher#atomic_persist`:
-
-```rb
-# in a background job
-attacher.refresh_metadata! # refresh_metadata plugin
-attacher.atomic_persist # persists attachment data
-```
-
-The record is first reloaded in order to check whether the attachment hasn't
-changed, and if it hasn't the attachment is persisted. If the attachment has
-changed, `Shrine::AttachmentChanged` exception is raised.
-
-#### Reloader & persister
-
-You can change how the record is reloaded or persisted during atomic
-persistence:
-
-```rb
-# reloader
-attacher.atomic_persist(reload: :lock)    # uses database locking (default)
-attacher.atomic_persist(reload: :fetch)   # reloads with no locking
-attacher.atomic_persist(reload: ->(&b){}) # custom reloader (see atomic_helpers plugin docs)
-attacher.atomic_persist(reload: false)    # skips reloading
-
-# persister
-attacher.atomic_persist(persist: :save) # persists stored file (default)
-attacher.atomic_persist(persist: ->{})  # custom persister (see atomic_helpers plugin docs)
-attacher.atomic_persist(persist: false) # skips persistence
-```
-
-For more details, see the [`atomic_helpers`][atomic_helpers] plugin docs.
-
-### Persistence
-
-You can call `Attacher#persist` to save any changes to the underlying record:
-
-```rb
-attacher.attach(io)
-attacher.persist # saves the underlying record
-```
-
-### With other database plugins
-
-If you have another database plugin loaded together with the `activerecord`
-plugin, you can prefix any method above with `activerecord_*` to avoid naming
-clashes:
-
-```rb
-attacher.activerecord_atomic_promote
-attacher.activerecord_atomic_persist
-attacher.activerecord_persist
-```
+See [persistence] docs for more details.
 
 [activerecord]: /lib/shrine/plugins/activerecord.rb
 [Active Record]: https://guides.rubyonrails.org/active_record_basics.html
@@ -258,5 +166,4 @@ attacher.activerecord_persist
 [callbacks]: https://guides.rubyonrails.org/active_record_callbacks.html
 [bug with transaction callbacks]: https://github.com/rails/rails/issues/14493
 [validation]: /doc/plugins/validation.md#readme
-[atomic_helpers]: /doc/plugins/atomic_helpers.md#readme
-[backgrounding]: /doc/plugins/backgrounding.md#readme
+[persistence]: /doc/plugins/persistence.md#readme

data/doc/plugins/add_metadata.md

@@ -6,7 +6,7 @@ extracting and adding custom metadata values.
 ```rb
 plugin :add_metadata
 
-add_metadata :exif do |io, context|
+add_metadata :exif do |io|
   begin
     Exif::Data.new(io).to_h
   rescue Exif::NotReadable # not a valid image
@@ -16,7 +16,7 @@ end
 ```
 
 The above will add "exif" to the metadata hash, and also create the `#exif`
-reader method on Shrine::UploadedFile.
+reader method on `Shrine::UploadedFile`.
 
 ```rb
 image.metadata["exif"]
@@ -24,11 +24,13 @@ image.metadata["exif"]
 image.exif
 ```
 
+## Multiple values
+
 You can also extract multiple metadata values at once, by using `add_metadata`
 without an argument and returning a hash of metadata.
 
 ```rb
-add_metadata do |io, context|
+add_metadata do |io|
   begin
     data = Exif::Data.new(io)
   rescue Exif::NotReadable # not a valid image
@@ -50,12 +52,14 @@ metadata on Shrine::UploadedFile, but you can create them via
 metadata_method :date_time, :flash
 ```
 
+## Ensuring file
+
 The `io` might not always be a file object, so if you're using an analyzer
 which requires the source file to be on disk, you can use `Shrine.with_file` to
 ensure you have a file object.
 
 ```rb
-add_metadata do |io, context|
+add_metadata do |io|
   movie = Shrine.with_file(io) { |file| FFMPEG::Movie.new(file.path) }
 
   { "duration"   => movie.duration,
@@ -65,11 +69,29 @@ add_metadata do |io, context|
 end
 ```
 
-Any previously extracted metadata can be accessed via `context[:metadata]`:
+## Uploader options
+
+Uploader options are also yielded to the block, you can access them for more
+context:
+
+```rb
+add_metadata do |io, **options|
+  options #=>
+  # {
+  #   record:   #<Photo>,
+  #   name:     :image,
+  #   action:   :store,
+  #   metadata: { ... },
+  #   ...
+  # }
+end
+```
+
+The `:metadata` option holds metadata that was extracted so far:
 
 ```rb
-add_metadata :foo do |io, context|
-  context[:metadata] #=>
+add_metadata :foo do |io, metadata:, **|
+  metadata #=>
   # {
   #   "size"      => 239823,
   #   "filename"  => "nature.jpg",
@@ -79,8 +101,8 @@ add_metadata :foo do |io, context|
   "foo"
 end
 
-add_metadata :bar do |io, context|
-  context[:metadata] #=>
+add_metadata :bar do |io, metadata:, **|
+  metadata #=>
   # {
   #   "size"      => 239823,
   #   "filename"  => "nature.jpg",

data/doc/plugins/atomic_helpers.md

@@ -18,9 +18,9 @@ given attachment data matches the attached file on the record.
 ```rb
 # with a model instance
 Shrine::Attacher.retrieve(
-  model:  photo,
-  name:   :image,
-  data:   { "id" => "...", "storage" => "...", "metadata" => { ... } },
+  model: photo,
+  name:  :image,
+  file:  { "id" => "abc123", "storage" => "cache" },
 )
 #=> #<Shrine::Attacher ...>
 
@@ -28,7 +28,7 @@ Shrine::Attacher.retrieve(
 Shrine::Attacher.retrieve(
   entity: photo,
   name:   :image,
-  data:   { "id" => "...", "storage" => "...", "metadata" => { ... } },
+  file:   { "id" => "abc123", "storage" => "cache" },
 )
 #=> #<Shrine::Attacher ...>
 ```
@@ -42,7 +42,7 @@ class Photo
 end
 ```
 ```rb
-Shrine::Attacher.retrieve(model: photo, name: :image, data: { ... })
+Shrine::Attacher.retrieve(model: photo, name: :image, file: { ... })
 #=> #<ImageUploader::Attacher ...>
 ```
 
@@ -51,7 +51,7 @@ Otherwise it will call `Attacher.from_model`/`Attacher.from_entity` from the
 `Attacher.retrieve` on the appropriate attacher class.
 
 ```rb
-ImageUploader::Attacher.retrieve(entity: photo, name: :image, data: { ... })
+ImageUploader::Attacher.retrieve(entity: photo, name: :image, file: { ... })
 #=> #<ImageUploader::Attacher ...>
 ```
 
@@ -60,16 +60,30 @@ a `Shrine::AttachmentChanged` exception is raised. Note that metadata is
 allowed to differ, Shrine will only compare location and storage of the file.
 
 ```rb
-photo.image_data #=> '{"id":"foo","storage":"cache","metadata":{...}}'
+photo.image_data #=> '{"id":"foo","storage":"store","metadata":{...}}'
 
 Shrine::Attacher.retrieve(
   model: photo,
   name: :image,
-  data: { "id" => "bar", "storage" => "cache", "metadata" => { ... } },
+  file: { "id" => "bar", "storage" => "store" },
 )
 # ~> Shrine::AttachmentChanged: attachment has changed
 ```
 
+### File data
+
+The `Attacher#file_data` method can be used for sending the attached file data
+into a background job. It returns only location and storage of the attached
+file, leaving out any metadata or derivatives data that `Attacher#data` would
+return. This way the background job payload is kept light.
+
+```rb
+attacher.file_data #=> { "id" => "abc123", "storage" => "store" }
+```
+
+This value can then be passed as the `:file` argument to
+`Shrine::Attacher.retrieve`.
+
 ## Promoting
 
 The `Attacher#abstract_atomic_promote` method provided by the plugin promotes
@@ -94,6 +108,15 @@ attacher.stored? #=> true
 If the attachment has changed during promotion, the promoted file is deleted and
 a `Shrine::AttachmentChanged` exception is raised.
 
+If you want to execute some code after the attachment change check but before
+persistence, you can pass a block:
+
+```rb
+attacher.abstract_atomic_promote(**options) do |reloaded_attacher|
+  # this will be executed before persistence
+end
+```
+
 Any additional options to `Attacher#abstract_atomic_promote` are forwarded to
 `Attacher#promote`.
 
@@ -142,7 +165,8 @@ attacher.set(new_file)
 attacher.abstract_atomic_persist(original_file, **options)
 ```
 
-If you want to execute some code before persistence, you can pass a block:
+If you want to execute some code after the attachment change check but before
+persistence, you can pass a block:
 
 ```rb
 attacher.abstract_atomic_persist(**options) do |reloaded_attacher|

data/doc/plugins/cached_attachment_data.md

@@ -13,13 +13,13 @@ cached file as JSON, and should be used to set the value of the hidden form
 field.
 
 ```rb
-@user.cached_avatar_data #=> '{"id":"38k25.jpg","storage":"cache","metadata":{...}}'
+photo.cached_image_data #=> '{"id":"38k25.jpg","storage":"cache","metadata":{...}}'
 ```
 
-This method delegates to `Attacher#read_cached`:
+This method delegates to `Attacher#cached_data`:
 
 ```rb
-attacher.read_cached #=> '{"id":"38k25.jpg","storage":"cache","metadata":{...}}'
+attacher.cached_data #=> '{"id":"38k25.jpg","storage":"cache","metadata":{...}}'
 ```
 
 [cached_attachment_data]: /lib/shrine/plugins/cached_attachment_data.rb

data/doc/plugins/data_uri.md

@@ -7,23 +7,22 @@ This plugin is useful for example when using [HTML5 Canvas].
 plugin :data_uri
 ```
 
-If your attachment is called "avatar", this plugin will add `#avatar_data_uri`
-and `#avatar_data_uri=` methods to your model.
+The plugin will add the `#<name>_data_uri` writer to your model, which parses
+the given data URI string and uploads it to temporary storage:
 
 ```rb
-user.avatar #=> nil
-user.avatar_data_uri = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA"
-user.avatar #=> #<Shrine::UploadedFile>
-
-user.avatar.mime_type         #=> "image/png"
-user.avatar.size              #=> 43423
+photo.image_data_uri = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA"
+photo.image.mime_type #=> "image/png"
+photo.image.size      #=> 43423
 ```
 
-You can also use `#data_uri=` and `#data_uri` methods directly on the
-`Shrine::Attacher` (which the model methods just delegate to):
+If you're using `Shrine::Attacher` directly, you can use
+`Attacher#assign_data_uri`:
 
 ```rb
-attacher.data_uri = "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA"
+attacher.assign_data_uri("data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA")
+attacher.file.mime_type #=> "image/png"
+attacher.file.size      #=> 43423
 ```
 
 ## Errors
@@ -36,13 +35,13 @@ plugin :data_uri, error_message: "data URI was invalid"
 plugin :data_uri, error_message: ->(uri) { I18n.t("errors.data_uri_invalid") }
 ```
 
-## Upload options
+## Uploader options
 
-If you want to pass additional options for `Shrine#upload`, you can use
-`#assign_data_uri`:
+Any options passed to `Attacher#assign_data_uri` will be forwarded to
+`Attacher#assign` (and `Shrine#upload`):
 
 ```rb
-attacher.assign_data_uri(uri, metadata: { "mime_type" => "text/plain" })
+attacher.assign_data_uri(uri, metadata: { "filename" => "nature.jpg" })
 ```
 
 ## File extension
@@ -56,9 +55,7 @@ load the `infer_extension` plugin to infer it from the MIME type.
 plugin :infer_extension
 ```
 
-## API
-
-### `Shrine.data_uri`
+## Parsing 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
@@ -90,7 +87,7 @@ io = Shrine.data_uri("data:,content", filename: "foo.txt")
 io.original_filename #=> "foo.txt"
 ```
 
-### `UploadedFile#data_uri` and `UploadedFile#base64`
+### Generating data URI
 
 This plugin also adds `UploadedFile#data_uri` method, which returns a
 base64-encoded data URI of the file content, and `UploadedFile#base64`, which

data/doc/plugins/default_storage.md

@@ -1,19 +1,43 @@
 # Default Storage
 
-The [`default_storage`][default_storage] plugin enables you to change which
-storages are going to be used for this uploader's attacher (the default is
-`:cache` and `:store`).
+The [`default_storage`][default_storage] plugin allows you to change the
+default temporary and permanent storage a `Shrine::Attacher` object will use
+(the default is `:cache` and `:store`).
 
 ```rb
-plugin :default_storage, cache: :special_cache, store: :special_store
+plugin :default_storage, cache: :other_cache, store: :other_store
 ```
 
-You can also pass a block and choose the values depending on the record values
-and the name of the attachment. This is useful if you're using the
-`dynamic_storage` plugin. Example:
+If you want the storage to be dynamic based on `Attacher` data, you can use a
+block, and it will be evaluated in context of the `Attacher` instance:
 
 ```rb
-plugin :default_storage, store: ->(record, name) { :"store_#{record.username}" }
+plugin :default_storage, store: -> {
+  if record.is_a?(Photo)
+    :photo_store
+  else
+    :store
+  end
+}
 ```
 
+You can also set default storage with `Attacher#default_cache` and
+`Attacher#default_store`:
+
+```rb
+# default temporary storage
+Attacher.default_cache :other_cache
+# or
+Attacher.default_cache { :other_cache }
+
+# default permanent storage
+Attacher.default_store :other_store
+# or
+Attacher.default_store { :other_store }
+```
+
+The dynamic block is useful in combination with the
+[`dynamic_storage`][dynamic_storage] plugin.
+
 [default_storage]: /lib/shrine/plugins/default_storage.rb
+[dynamic_storage]: /doc/plugins/dynamic_storage.md#readme