shrine 3.0.0.beta → 3.0.0.beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c5f2d3f6519d99e728cdfffe80783d0278f171bb6f8a850b4840d2d9fb92eda5
-  data.tar.gz: 28566d4950a3ad23cb657e699db8a0861283efb8709a7a70d6a20c83d8a5c0c7
+  metadata.gz: e35bbe08c0a54aca90746357823eea8bd7f65f7ee64a988fe6bc9c3931f70a91
+  data.tar.gz: 1c70a7212c59f13fa435b866d0dad8c81989d7ee41722247d5107edec461047b
 SHA512:
-  metadata.gz: 0cc989a0037051dd2cc84785a7a0a6080667e450ae8f1e95c4204d4474f9fac98d97498f435c82aed20036963ca86425ccf31e3d07ea274e9113e3b79439bb16
-  data.tar.gz: 6f4e12336f30753d55b53337efd695a712c4971744bd012497f79418890b3ed910084e6af7fe57c5c05025f854f44ffbb969e5c0aa3cba4aa0d9b729d1225267
+  metadata.gz: 784c4f79052ef3132ffe26544a79de6f27e9209563cd9c08d475a3e52e0b7b201041f516caebc00315f802c1c9d18e7bd74b0e8e5977576727dccfefe47d0c3b
+  data.tar.gz: 6788e1946a1062a3f184b87cf016b7104d6c524621853fb38a8c092d245fa244625a16866dde958bf53caa4bbb113b6d0e01fb09c7340b39633360e40b5d4ee4

data/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 3.0.0.beta2 (2019-09-11)
+
+* `column` – Allow `Attacher#load_column` to receive a hash (@janko)
+
+* `activerecord` – Fix integration not working with JSON columns (@janko)
+
+* `mirroring` – Add new plugin for replicating uploads and deletes to other storages (@janko)
+
+* `model` – Change disabling model attachment behaviour from `type: :entity` to `model: false` (@janko)
+
+* `sequel` – Rename `:callbacks` option to `:hooks` (@janko)
+
+* `derivatives` – Auto-download `UploadedFile` objects passed to `Attacher#process_derivatives` (@janko)
+
 ## 3.0.0.beta (2019-08-29)
 
 * `atomic_helpers` – Rename `:data` argument to `:file` in `Attacher.retrieve` (@janko)

data/README.md

@@ -119,9 +119,10 @@ class Photo < Sequel::Model # ActiveRecord::Base
 end
 ```
 
-Let's now add the form fields which will use this virtual attribute. We need
-(1) a file field for choosing files, and (2) a hidden field for retaining the
-uploaded file in case of validation errors and for potential [direct uploads].
+Let's now add the form fields which will use this virtual attribute (which is
+`image`, NOT `image_data`). We need (1) a file field for choosing files, and
+(2) a hidden field for retaining the uploaded file in case of validation errors
+and for potential [direct uploads].
 
 ```rb
 # with Rails form builder:

data/doc/plugins/activerecord.md

@@ -9,15 +9,35 @@ plugin :activerecord
 
 ## Attachment
 
-When `Shrine::Attachment` module is included into an `ActiveRecord::Base`
-subclass, additional [callbacks] are added to tie the attachment process to the
-record lifecycle.
+Including a `Shrine::Attachment` module into an `ActiveRecord::Base` subclass
+will:
+
+* add [model] attachment methods
+* add [validations](#validations) and [callbacks](#callbacks) to tie attachment
+  process to the record lifecycle
 
 ```rb
-class Photo < ActiveRecord::Base
-  include ImageUploader::Attachment(:image) # adds callbacks & validations
+class Photo < ActiveRecord::Base # has `image_data` column
+  include ImageUploader::Attachment(:image) # adds methods, callbacks & validations
 end
 ```
+```rb
+photo = Photo.new
+
+photo.image = file # cache attachment
+
+photo.image      #=> #<Shrine::UploadedFile @id="bc2e13.jpg" @storage_key=:cache ...>
+photo.image_data #=> '{"id":"bc2e13.jpg","storage":"cache","metadata":{...}}'
+
+photo.save # persist, promote attachment, then persist again
+
+photo.image      #=> #<Shrine::UploadedFile @id="397eca.jpg" @storage_key=:store ...>
+photo.image_data #=> '{"id":"397eca.jpg","storage":"store","metadata":{...}}'
+
+photo.destroy # delete attachment
+
+photo.image.exists? #=> false
+```
 
 ### Callbacks
 
@@ -69,8 +89,8 @@ module *after* they have all been defined.
 
 #### 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`:
+If you don't want the attachment module to add any callbacks to your model, you
+can set `:callbacks` to `false`:
 
 ```rb
 plugin :activerecord, callbacks: false
@@ -104,7 +124,8 @@ presence validator:
 
 ```rb
 class Photo < ActiveRecord::Base
-  include ImageUploader::Attachment.new(:image)
+  include ImageUploader::Attachment(:image)
+
   validates_presence_of :image
 end
 ```
@@ -147,10 +168,33 @@ plugin :activerecord, validations: false
 
 ## Attacher
 
-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.
+You can also use `Shrine::Attacher` directly (with or without the
+`Shrine::Attachment` module):
+
+```rb
+class Photo < ActiveRecord::Base # has `image_data` column
+end
+```
+```rb
+photo    = Photo.new
+attacher = ImageUploader::Attacher.from_model(photo, :image)
+
+attacher.assign(file) # cache
+
+attacher.file    #=> #<Shrine::UploadedFile @id="bc2e13.jpg" @storage_key=:cache ...>
+photo.image_data #=> '{"id":"bc2e13.jpg","storage":"cache","metadata":{...}}'
+
+photo.save        # persist
+attacher.finalize # promote
+photo.save        # persist
+
+attacher.file    #=> #<Shrine::UploadedFile @id="397eca.jpg" @storage_key=:store ...>
+photo.image_data #=> '{"id":"397eca.jpg","storage":"store","metadata":{...}}'
+```
+
+### Persistence
 
-The following persistence methods are added to the attacher:
+The following persistence methods are added to `Shrine::Attacher`:
 
 | Method                    | Description                                                            |
 | :-----                    | :----------                                                            |

data/doc/plugins/derivatives.md

@@ -111,8 +111,9 @@ photo.image_data #=>
 # }
 ```
 
-When using `Shrine::Attacher` directly, derivatives are created using
-`Attacher#create_derivatives`:
+The `#<name>_derivatives!` model method delegates to
+`Attacher#create_derivatives`, which you can use if you're using
+`Shrine::Attacher` directly:
 
 ```rb
 attacher.file #=> #<Shrine::UploadedFile @id="original.jpg" @storage_key=:store ...>
@@ -127,6 +128,18 @@ attacher.derivatives #=>
 # }
 ```
 
+By default, the `Attacher#create_derivatives` method downloads the attached
+file, calls the processor, uploads results to attacher's permanent storage, and
+saves uploaded files on the attacher.
+
+Any additional arguments are forwarded to
+[`Attacher#process_derivatives`](#processing-derivatives):
+
+```rb
+attacher.create_derivatives(:thumbnails, different_source) # pass a different source file
+attacher.create_derivatives(:thumbnails, foo: "bar")       # pass custom options to the processor
+```
+
 ### Derivatives storage
 
 By default, derivatives are uploaded to the permanent storage of the attacher.
@@ -308,15 +321,8 @@ Attacher.derivatives_processor :my_processor do |original|
 end
 ```
 
-The [`Attacher#create_derivatives`](#creating-derivatives) method will call
-the processor and upload results.
-
-```rb
-attacher.create_derivatives(:my_processor)
-```
-
-Internally this calls `Attacher#process_derivatives`, which calls the
-processor and returns processed files:
+The `Attacher#create_derivatives` method internally calls
+`Attacher#process_derivatives`, which in turn calls the processor:
 
 ```rb
 files = attacher.process_derivatives(:my_processor)
@@ -340,8 +346,8 @@ Attacher.derivatives_processor :my_processor do |original|
 end
 ```
 
-Moreover, any options passed to `Attacher#process_derivatives` (or
-`Attacher#create_derivatives`) will be forwarded to the processor:
+Moreover, any options passed to `Attacher#process_derivatives` will be
+forwarded to the processor:
 
 ```rb
 attacher.process_derivatives(:my_processor, foo: "bar")
@@ -355,7 +361,7 @@ end
 
 ### Source file
 
-The `Attacher#process_derivatives` method will automatically download the
+By default, the `Attacher#process_derivatives` method will download the
 attached file and pass it to the processor:
 
 ```rb
@@ -368,10 +374,9 @@ end
 attacher.process_derivatives(:my_processor) # downloads attached file and passes it to the processor
 ```
 
-If you already have the source file locally, or if you're calling multiple
-processors in a row and want to avoid downloading the same source file each
-time, you can pass the source file as the second argument to
-`Attacher#process_derivatives` (or `Attacher#create_derivatives`):
+If you want to use a different source file, or if you're calling multiple
+processors in a row and want to avoid re-downloading the same source file each
+time, you can pass the source file as the second argument:
 
 ```rb
 # this way the source file is downloaded only once

data/doc/plugins/entity.md

@@ -20,7 +20,7 @@ These methods read attachment data from the `#<name>_data` attribute on the
 entity instance.
 
 ```rb
-class Photo < Entity(:image_data)
+class Photo < Entity(:image_data) # has `image_data` reader
   include ImageUploader::Attachment(:image)
 end
 ```
@@ -117,6 +117,29 @@ attacher.store_key #=> :other_store
 
 ## Attacher
 
+You can also use `Shrine::Attacher` directly (with or without the
+`Shrine::Attachment` module):
+
+```rb
+class Photo < Entity(:image_data) # has `image_data` reader
+end
+```
+```rb
+photo    = Photo.new(image_data: '{"id":"...","storage":"...","metadata":{...}}')
+attacher = ImageUploader::Attacher.from_entity(photo, :image)
+
+attacher.file #=> #<Shrine::UploadedFile @id="bc2e13.jpg" @storage_key=:store ...>
+
+attacher.attach(file)
+attacher.file          #=> #<Shrine::UploadedFile @id="397eca.jpg" @storage_key=:store ...>
+attacher.column_values #=> { image_data: '{"id":"397eca.jpg","storage":"store","metadata":{...}}' }
+
+photo    = Photo.new(attacher.column_values)
+attacher = ImageUploader::Attacher.from_entity(photo, :image)
+
+attacher.file #=> #<Shrine::UploadedFile @id="397eca.jpg" @storage_key=:store ...>
+```
+
 ### Loading entity
 
 The `Attacher.from_entity` method can be used for creating an `Attacher`

data/doc/plugins/mirroring.md

@@ -0,0 +1,87 @@
+# Mirroring
+
+The [`mirroring`][mirroring] plugin enables replicating uploads and deletes to
+other storages. This can be useful for setting up a backup storage, or when
+migrating files from one storage to another.
+
+```rb
+Shrine.plugin :mirroring, mirror: { store: :other_store }
+```
+
+With the above setup, any upload and delete to `:store` will be replicated to
+`:other_store`.
+
+```rb
+uploaded_file = Shrine.upload(io, :store) # uploads to :store and :other_store
+uploaded_file.delete                      # deletes from :store and :other_store
+```
+
+## Multiple storages
+
+You can mirror to multiple storages by specifying an array:
+
+```rb
+Shrine.plugin :mirroring, mirror: {
+  store: [:other_store_1, :other_store_2]
+}
+```
+
+## Backup storage
+
+If you want the mirror storage to act as a backup, you can disable mirroring
+deletes:
+
+```rb
+Shrine.plugin :mirroring, mirror: { ... }, delete: false
+```
+
+## Backgrounding
+
+You can have mirroring performed in a background job:
+
+```rb
+Shrine.mirror_upload do |uploaded_file|
+  MirrorUploadJob.perform_async(uploaded_file.shrine_class, uploaded_file.data)
+end
+
+Shrine.mirror_delete do |uploaded_file|
+  MirrorDeleteJob.perform_async(uploaded_file.shrine_class, uploaded_file.data)
+end
+```
+```rb
+class MirrorUploadJob
+  include Sidekiq::Worker
+  def perform(shrine_class, file_data)
+    uploaded_file = Object.const_get(shrine_class).uploaded_file(file_data)
+    uploaded_file.mirror_upload
+  end
+end
+```
+```rb
+class MirrorDeleteJob
+  include Sidekiq::Worker
+  def perform(shrine_class, file_data)
+    uploaded_file = Object.const_get(shrine_class).uploaded_file(file_data)
+    uploaded_file.mirror_delete
+  end
+end
+```
+
+## API
+
+You can mirror manually via `UploadedFile#mirror_upload` and
+`UploadedFile#mirror_delete`:
+
+```rb
+# disable automatic mirroring of uploads and deletes
+Shrine.plugin :mirroring, mirror: { ... }, upload: false, delete: false
+```
+```rb
+file = Shrine.upload(io, :store) # upload to :store
+file.mirror_upload               # upload to :other_store
+
+file.delete                      # delete from :store
+file.mirror_delete               # delete from :other_store
+```
+
+[mirroring]: /lib/shrine/plugins/mirroring.rb

data/doc/plugins/model.md

@@ -1,6 +1,6 @@
 # Model
 
-The [`model`][model] plugin provides integration for handling atatchments on
+The [`model`][model] plugin provides integration for handling attachment on
 mutable structs. It is built on top of the [`entity`][entity] plugin.
 
 ```rb
@@ -9,24 +9,28 @@ plugin :model
 
 ## Attachment
 
-Including a `Shrine::Attachment` module into a model class will, in addition to
-methods from the `entity` plugin, add the `#<name>=` method for attaching
-files.
+Including a `Shrine::Attachment` module into a model class will:
 
-These methods read and write attachment data to the `#<name>_data` attribute on
-the model instance.
+* add [entity] attachment methods
+* add `#<name>=` and `#<name>_changed?` methods
 
 ```rb
-class Photo < Model(:image_data)
+class Photo < Model(:image_data) # has `image_data` accessor
   include ImageUploader::Attachment(:image)
 end
 ```
 ```rb
 photo = Photo.new
+
 photo.image = file
-photo.image          #=> #<ImageUploader::UploadedFile>
-photo.image_url      #=> "https://example.com/foo.jpg"
-photo.image_attacher #=> #<ImageUploader::Attacher>
+
+photo.image      #=> #<Shrine::UploadedFile @id="bc2e13.jpg" @storage_key=:cache ...>
+photo.image_data #=> '{"id":"bc2e13.jpg","storage":"cache","metadata":{...}}'
+
+photo.image_attacher.finalize
+
+photo.image      #=> #<Shrine::UploadedFile @id="397eca.jpg" @storage_key=:store ...>
+photo.image_data #=> '{"id":"397eca.jpg","storage":"store","metadata":{...}}'
 ```
 
 #### `#<name>=`
@@ -98,16 +102,38 @@ photo.image_attacher.cache_key #=> :other_cache
 ### Entity
 
 If you still want to include `Shrine::Attachment` modules to immutable
-entities, you can disable "model" behaviour by passing `type: :entity`:
+entities, you can disable "model" behaviour by passing `model: false`:
 
 ```rb
 class Photo < Entity(:image_data)
-  include ImageUploader::Attachment(:image, type: :entity)
+  include ImageUploader::Attachment(:image, model: false)
 end
 ```
 
 ## Attacher
 
+You can also use `Shrine::Attacher` directly (with or without the
+`Shrine::Attachment` module):
+
+```rb
+class Photo < Model(:image_data) # has `image_data` accessor
+end
+```
+```rb
+photo    = Photo.new
+attacher = ImageUploader::Attacher.from_model(photo, :image)
+
+attacher.assign(file) # cache
+
+attacher.file    #=> #<Shrine::UploadedFile @id="bc2e13.jpg" @storage_key=:cache ...>
+photo.image_data #=> '{"id":"bc2e13.jpg","storage":"cache","metadata":{...}}'
+
+attacher.finalize # promote
+
+attacher.file    #=> #<Shrine::UploadedFile @id="397eca.jpg" @storage_key=:store ...>
+photo.image_data #=> '{"id":"397eca.jpg","storage":"store","metadata":{...}}'
+```
+
 ### Loading model
 
 The `Attacher.from_model` method can be used for creating an `Attacher`

data/doc/plugins/sequel.md

@@ -9,17 +9,36 @@ plugin :sequel
 
 ## Attachment
 
-When `Shrine::Attachment` module is included into a `Sequel::Model` subclass,
-additional [hooks] are added to tie the attachment process to the record
-lifecycle.
+Including a `Shrine::Attachment` module into a `Sequel::Model` subclass will:
+
+* add [model] attachment methods
+* add [validations](#validations) and [hooks](#hooks) to tie attachment process
+  to the record lifecycle
 
 ```rb
-class Photo < Sequel::Model
-  include ImageUploader::Attachment(:image) # adds callbacks & validations
+class Photo < Sequel::Model # has `image_data` column
+  include ImageUploader::Attachment(:image) # adds methods, callbacks & validations
 end
 ```
+```rb
+photo = Photo.new
+
+photo.image = file # cache attachment
+
+photo.image      #=> #<Shrine::UploadedFile @id="bc2e13.jpg" @storage_key=:cache ...>
+photo.image_data #=> '{"id":"bc2e13.jpg","storage":"cache","metadata":{...}}'
+
+photo.save # persist, promote attachment, then persist again
 
-### Callbacks
+photo.image      #=> #<Shrine::UploadedFile @id="397eca.jpg" @storage_key=:store ...>
+photo.image_data #=> '{"id":"397eca.jpg","storage":"store","metadata":{...}}'
+
+photo.destroy # delete attachment
+
+photo.image.exists? #=> false
+```
+
+### Hooks
 
 #### After Save
 
@@ -52,13 +71,13 @@ photo.destroy
 photo.image.exists? #=> false
 ```
 
-#### Skipping Callbacks
+#### Skipping Hooks
 
-If you don't want the attachment module to add any callbacks to your Sequel
-model, you can set `:callbacks` to `false`:
+If you don't want the attachment module to add any hooks to your model, you can
+set `:hooks` to `false`:
 
 ```rb
-plugin :sequel, callbacks: false
+plugin :sequel, hooks: false
 ```
 
 ### Validations
@@ -89,9 +108,7 @@ presence validator:
 
 ```rb
 class Photo < Sequel::Model
-  include ImageUploader::Attachment.new(:image)
-
-  plugin :validation_helpers
+  include ImageUploader::Attachment(:image)
 
   def validate
     super
@@ -111,10 +128,33 @@ plugin :sequel, validations: false
 
 ## Attacher
 
-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.
+You can also use `Shrine::Attacher` directly (with or without the
+`Shrine::Attachment` module):
+
+```rb
+class Photo < Sequel::Model # has `image_data` column
+end
+```
+```rb
+photo    = Photo.new
+attacher = ImageUploader::Attacher.from_model(photo, :image)
+
+attacher.assign(file) # cache
+
+attacher.file    #=> #<Shrine::UploadedFile @id="bc2e13.jpg" @storage_key=:cache ...>
+photo.image_data #=> '{"id":"bc2e13.jpg","storage":"cache","metadata":{...}}'
+
+photo.save        # persist
+attacher.finalize # promote
+photo.save        # persist
+
+attacher.file    #=> #<Shrine::UploadedFile @id="397eca.jpg" @storage_key=:store ...>
+photo.image_data #=> '{"id":"397eca.jpg","storage":"store","metadata":{...}}'
+```
+
+### Pesistence
 
-The following persistence methods are added to the attacher:
+The following persistence methods are added to `Shrine::Attacher`:
 
 | Method                    | Description                                                            |
 | :-----                    | :----------                                                            |
@@ -127,6 +167,5 @@ See [persistence] docs for more details.
 [sequel]: /lib/shrine/plugins/sequel.rb
 [Sequel]: https://sequel.jeremyevans.net/
 [model]: /doc/plugins/model.md#readme
-[hooks]: http://sequel.jeremyevans.net/rdoc/files/doc/model_hooks_rdoc.html
 [validation]: /doc/plugins/validation.md#readme
 [persistence]: /doc/plugins/persistence.md#readme

data/lib/shrine/plugins/_persistence.rb

@@ -9,13 +9,15 @@ class Shrine
     module Persistence
       def self.load_dependencies(uploader, *)
         uploader.plugin :atomic_helpers
+        uploader.plugin :entity
       end
 
-      # Defines the following attacher methods for a persistence plugin:
+      # Using #<name>_persist, #<name>_reload, and #<name>?, defines the
+      # following methods for a persistence plugin:
       #
-      # * #persist (calls #<name>_persist and #<name>?)
-      # * #atomic_persist (calls #<name>_reload, #<name>_persist and #<name>?)
-      # * #atomic_promote (calls #<name>_reload, #<name>_persist and #<name>?)
+      #   * Attacher#persist
+      #   * Attacher#atomic_persist
+      #   * Attacher#atomic_promote
       def self.configure(uploader, plugin:)
         plugin_name = plugin.to_s.split("::").last.downcase
 
@@ -46,6 +48,14 @@ class Shrine
 
             send(:"#{plugin_name}_persist")
           end
+
+          define_method :hash_attribute? do
+            return super() unless send(:"#{plugin_name}?")
+
+            respond_to?(:"#{plugin_name}_hash_attribute?", true) &&
+            send(:"#{plugin_name}_hash_attribute?")
+          end
+          private :hash_attribute?
         end
       end
 
@@ -61,6 +71,20 @@ class Shrine
         def persist(*)
           raise NotImplementedError, "unhandled by a persistence plugin"
         end
+
+        # Disable attachment data serialization for data attributes that
+        # accept and return hashes.
+        def set_entity(*)
+          super
+          @column_serializer = nil if hash_attribute?
+        end
+
+        private
+
+        # Whether the data attribute accepts and returns hashes.
+        def hash_attribute?
+          false
+        end
       end
     end
 

data/lib/shrine/plugins/activerecord.rb

@@ -67,27 +67,16 @@ class Shrine
         end
       end
 
+      # The _persistence plugin uses #activerecord_persist,
+      # #activerecord_reload and #activerecord? to implement the following
+      # methods:
+      #
+      #   * Attacher#persist
+      #   * Attacher#atomic_persist
+      #   * Attacher#atomic_promote
       module AttacherMethods
-        # The _persistence plugin defines the following methods:
-        #
-        #   * #persist (calls #activerecord_persist and #activerecord?)
-        #   * #atomic_persist (calls #activerecord_lock, #activerecord_persist and #activerecord?)
-        #   * #atomic_promote (calls #activerecord_lock, #activerecord_persist and #activerecord?)
         private
 
-        # ActiveRecord JSON column attribute needs to be assigned with a Hash.
-        def serialize_column(data)
-          activerecord_json_column? ? data : super
-        end
-
-        # Returns true if the data attribute represents a JSON or JSONB column.
-        def activerecord_json_column?
-          return false unless activerecord?
-          return false unless column = record.class.columns_hash[attribute.to_s]
-
-          [:json, :jsonb].include?(column.type)
-        end
-
         # Saves changes to the model instance, skipping validations. Used by
         # the _persistence plugin.
         def activerecord_persist
@@ -100,6 +89,14 @@ class Shrine
           record.transaction { yield record.clone.reload(lock: true) }
         end
 
+        # Returns true if the data attribute represents a JSON or JSONB column.
+        # Used by the _persistence plugin to determine whether serialization
+        # should be skipped.
+        def activerecord_hash_attribute?
+          column = record.class.columns_hash[attribute.to_s]
+          column && [:json, :jsonb].include?(column.type)
+        end
+
         # Returns whether the record is an ActiveRecord model. Used by the
         # _persistence plugin.
         def activerecord?

data/lib/shrine/plugins/column.rb

@@ -9,7 +9,7 @@ class Shrine
     # [doc/plugins/column.md]: https://github.com/shrinerb/shrine/blob/master/doc/plugins/column.md
     module Column
       def self.configure(uploader, **opts)
-        uploader.opts[:column] ||= { serializer: JsonSerializer.new(JSON) }
+        uploader.opts[:column] ||= { serializer: JsonSerializer }
         uploader.opts[:column].merge!(opts)
       end
 
@@ -62,9 +62,11 @@ class Shrine
         #     Attacher.serialize_column(nil)
         #     #=> nil
         def serialize_column(data)
-          return data unless column_serializer && data
-
-          column_serializer.dump(data)
+          if column_serializer && data
+            column_serializer.dump(data)
+          else
+            data
+          end
         end
 
         # Converts the column data string into a hash (parses JSON by default).
@@ -75,9 +77,11 @@ class Shrine
         #     Attacher.deserialize_column(nil)
         #     #=> nil
         def deserialize_column(data)
-          return data unless column_serializer && data
-
-          column_serializer.load(data)
+          if column_serializer && data.is_a?(String)
+            column_serializer.load(data)
+          else
+            data&.to_hash
+          end
         end
       end
 
@@ -85,16 +89,12 @@ class Shrine
       # create this wrapper class which calls JSON.generate and JSON.parse
       # instead.
       class JsonSerializer
-        def initialize(json)
-          @json = json
-        end
-
-        def dump(data)
-          @json.generate(data)
+        def self.dump(data)
+          JSON.generate(data)
         end
 
-        def load(data)
-          @json.parse(data)
+        def self.load(data)
+          JSON.parse(data)
         end
       end
     end

data/lib/shrine/plugins/derivatives.rb

@@ -252,9 +252,9 @@ class Shrine
         #
         #     attacher.process_derivatives(:thumbnails)
         #     #=> { small: #<File:...>, medium: #<File:...>, large: #<File:...> }
-        def process_derivatives(processor_name, source = nil, **options)
+        def process_derivatives(processor_name, source = file!, **options)
           processor    = self.class.derivatives_processor(processor_name)
-          fetch_source = source ? source.method(:tap) : file!.method(:download)
+          fetch_source = source.is_a?(UploadedFile) ? source.method(:download) : source.method(:tap)
           result       = nil
 
           fetch_source.call do |source_file|

data/lib/shrine/plugins/entity.rb

@@ -11,15 +11,14 @@ class Shrine
       end
 
       module AttachmentMethods
-        attr_reader :type
-
-        def initialize(name, type: :entity, **options)
+        def initialize(name, **options)
           super(name, **options)
-          @type = type
 
           define_entity_methods(name)
         end
 
+        private
+
         # Defines `#<name>`, `#<name>_url`, and `#<name>_attacher` methods.
         def define_entity_methods(name)
           super if defined?(super)
@@ -38,7 +37,7 @@ class Shrine
 
           # Returns an attacher instance.
           define_method :"#{name}_attacher" do |**options|
-            attachment.attacher(self, options)
+            attachment.send(:attacher, self, options)
           end
         end
 

data/lib/shrine/plugins/mirroring.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+class Shrine
+  module Plugins
+    module Mirroring
+      UPLOAD = -> (uploaded_file) { uploaded_file.mirror_upload }
+      DELETE = -> (uploaded_file) { uploaded_file.mirror_delete }
+
+      def self.configure(uploader, **opts)
+        uploader.opts[:mirroring] ||= { upload: UPLOAD, delete: DELETE }
+        uploader.opts[:mirroring].merge!(opts)
+
+        fail Error, ":mirror option is required for mirroring plugin" unless uploader.opts[:mirroring][:mirror]
+      end
+
+      module ClassMethods
+        def mirrors(storage_key = nil)
+          if storage_key
+            mirrors = opts[:mirroring][:mirror][storage_key]
+
+            fail Error, "no mirrors registered for storage #{storage_key.inspect}" unless mirrors
+
+            Array(mirrors)
+          else
+            opts[:mirroring][:mirror]
+          end
+        end
+
+        def mirror_upload(&block)
+          if block
+            opts[:mirroring][:upload] = block
+          else
+            opts[:mirroring][:upload]
+          end
+        end
+
+        def mirror_delete(&block)
+          if block
+            opts[:mirroring][:delete] = block
+          else
+            opts[:mirroring][:delete]
+          end
+        end
+      end
+
+      module InstanceMethods
+        def upload(io, **options)
+          uploaded_file = super
+
+          if self.class.mirrors[storage_key] && self.class.mirror_upload
+            self.class.mirror_upload.call(uploaded_file)
+          end
+
+          uploaded_file
+        end
+      end
+
+      module FileMethods
+        def mirror_upload
+          previously_opened = opened?
+
+          each_mirror do |mirror|
+            rewind if opened?
+
+            shrine_class.upload(self, mirror, location: id, close: false)
+          end
+        ensure
+          if opened? && !previously_opened
+            close
+            @io = nil
+          end
+        end
+
+        def delete
+          result = super
+
+          if shrine_class.mirrors[storage_key] && shrine_class.mirror_delete
+            shrine_class.mirror_delete.call(self)
+          end
+
+          result
+        end
+
+        def mirror_delete
+          each_mirror do |mirror|
+            self.class.new(id: id, storage: mirror).delete
+          end
+        end
+
+        private
+
+        def each_mirror(&block)
+          mirrors = shrine_class.mirrors(storage_key)
+          mirrors.map(&block)
+        end
+      end
+    end
+
+    register_plugin(:mirroring, Mirroring)
+  end
+end

data/lib/shrine/plugins/model.rb

@@ -16,28 +16,25 @@ class Shrine
       end
 
       module AttachmentMethods
-        # Allows specifying whether the attachment should be for a model
-        # (default) or an entity.
+        # Allows disabling model behaviour:
         #
-        #     Shrine::Attachment.new(:image)                # model (default)
-        #     Shrine::Attachment.new(:image, type: :model)  # model
-        #     Shrine::Attachment.new(:image, type: :entity) # entity
-        def initialize(name, **options)
-          super(name, type: :model, **options)
+        #     Shrine::Attachment.new(:image)               # model (default)
+        #     Shrine::Attachment.new(:image, model: false) # entity
+        def initialize(name, model: true, **options)
+          super(name, **options)
+          @model = model
         end
 
-        # We define model methods only on inclusion, if the attachment type is
-        # still "model". This gives other plugins the ability to force
-        # attachment type to "entity" for certain classes, and we can skip
-        # defining model methods in this case.
+        # We define model methods only on inclusion. This gives other plugins
+        # the ability to disable model behaviour for entity classes. In this
+        # case we want to skip defining model methods as well.
         def included(klass)
           super
-
-          return unless type == :model
-
-          define_model_methods(@name)
+          define_model_methods(@name) if model?
         end
 
+        private
+
         # Defines attachment setter and enhances the copy constructor.
         def define_model_methods(name)
           super if defined?(super)
@@ -61,17 +58,21 @@ class Shrine
 
         # Memoizes the attacher instance into an instance variable.
         def attacher(record, options)
-          return super unless type == :model
+          return super unless model?
 
           if !record.instance_variable_get(:"@#{@name}_attacher") || options.any?
-            attacher = super
-            attacher.set_model(record, @name)
+            attacher = record.class.send(:"#{@name}_attacher", options)
+            attacher.load_model(record, @name)
 
             record.instance_variable_set(:"@#{@name}_attacher", attacher)
           else
             record.instance_variable_get(:"@#{@name}_attacher")
           end
         end
+
+        def model?
+          @model
+        end
       end
 
       module AttacherClassMethods
@@ -92,6 +93,7 @@ class Shrine
         def initialize(model_cache: shrine_class.opts[:model][:cache], **options)
           super(**options)
           @model_cache = model_cache
+          @model       = nil
         end
 
         # Saves record and name and initializes attachment from the model
@@ -148,7 +150,7 @@ class Shrine
         # This allows users to still use the attacher with an entity instance
         # or without any record instance.
         def model?
-          instance_variable_defined?(:@model)
+          @model
         end
       end
     end

data/lib/shrine/plugins/sequel.rb

@@ -14,7 +14,12 @@ class Shrine
       end
 
       def self.configure(uploader, **opts)
-        uploader.opts[:sequel] ||= { callbacks: true, validations: true }
+        if opts.key?(:callbacks)
+          Shrine.deprecation("The :callbacks option in sequel plugin has been renamed to :hooks. The :callbacks alias will be removed in Shrine 4.")
+          opts[:hooks] = opts.delete(:callbacks)
+        end
+
+        uploader.opts[:sequel] ||= { hooks: true, validations: true }
         uploader.opts[:sequel].merge!(opts)
       end
 
@@ -38,7 +43,7 @@ class Shrine
             end
           end
 
-          if shrine_class.opts[:sequel][:callbacks]
+          if shrine_class.opts[:sequel][:hooks]
             define_method :before_save do
               super()
               if send(:"#{name}_attacher").changed?
@@ -76,36 +81,15 @@ class Shrine
         end
       end
 
+      # The _persistence plugin uses #sequel_persist, #sequel_reload and
+      # #sequel? to implement the following methods:
+      #
+      #   * Attacher#persist
+      #   * Attacher#atomic_persist
+      #   * Attacher#atomic_promote
       module AttacherMethods
-        # The _persistence plugin defines the following methods:
-        #
-        #   * #persist (calls #sequel_persist and #sequel?)
-        #   * #atomic_persist (calls #sequel_lock, #sequel_persist and #sequel?)
-        #   * #atomic_promote (calls #sequel_lock, #sequel_persist and #sequel?)
         private
 
-        # Sequel JSON column attribute with `pg_json` Sequel extension loaded
-        # returns a `Sequel::Postgres::JSONHashBase` object will be returned,
-        # which we convert into a Hash.
-        def deserialize_column(data)
-          sequel_json_column? ? data&.to_hash : super
-        end
-
-        # Sequel JSON column attribute with `pg_json` Sequel extension loaded
-        # can receive a Hash object, so there is no need to generate a JSON
-        # string.
-        def serialize_column(data)
-          sequel_json_column? ? data : super
-        end
-
-        # Returns true if the data attribute represents a JSON or JSONB column.
-        def sequel_json_column?
-          return false unless sequel?
-          return false unless column = record.class.db_schema[attribute]
-
-          [:json, :jsonb].include?(column[:type])
-        end
-
         # Saves changes to the model instance, skipping validations. Used by
         # the _persistence plugin.
         def sequel_persist
@@ -118,6 +102,14 @@ class Shrine
           record.db.transaction { yield record.dup.lock! }
         end
 
+        # Returns true if the data attribute represents a JSON or JSONB column.
+        # Used by the _persistence plugin to determine whether serialization
+        # should be skipped.
+        def sequel_hash_attribute?
+          column = record.class.db_schema[attribute]
+          column && [:json, :jsonb].include?(column[:type])
+        end
+
         # Returns whether the record is a Sequel model. Used by the
         # _persistence plugin.
         def sequel?

data/lib/shrine/version.rb

@@ -9,7 +9,7 @@ class Shrine
     MAJOR = 3
     MINOR = 0
     TINY  = 0
-    PRE   = "beta"
+    PRE   = "beta2"
 
     STRING = [MAJOR, MINOR, TINY, PRE].compact.join(".")
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: shrine
 version: !ruby/object:Gem::Version
-  version: 3.0.0.beta
+  version: 3.0.0.beta2
 platform: ruby
 authors:
 - Janko Marohnić
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-29 00:00:00.000000000 Z
+date: 2019-09-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: down
@@ -398,6 +398,7 @@ files:
 - doc/plugins/instrumentation.md
 - doc/plugins/keep_files.md
 - doc/plugins/metadata_attributes.md
+- doc/plugins/mirroring.md
 - doc/plugins/model.md
 - doc/plugins/module_include.md
 - doc/plugins/persistence.md
@@ -493,6 +494,7 @@ files:
 - lib/shrine/plugins/instrumentation.rb
 - lib/shrine/plugins/keep_files.rb
 - lib/shrine/plugins/metadata_attributes.rb
+- lib/shrine/plugins/mirroring.rb
 - lib/shrine/plugins/model.rb
 - lib/shrine/plugins/module_include.rb
 - lib/shrine/plugins/presign_endpoint.rb
@@ -547,7 +549,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
-rubygems_version: 3.0.3
+rubygems_version: 3.0.1
 signing_key: 
 specification_version: 4
 summary: Toolkit for file attachments in Ruby applications