deep_cloneable 2.3.2 → 3.2.0

data/lib/deep_cloneable/deep_clone.rb

@@ -0,0 +1,207 @@
+# frozen_string_literal: true
+
+module DeepCloneable
+  module DeepClone
+    # Deep dups an ActiveRecord model. See README.rdoc
+    def deep_clone(*args, &block)
+      options = args[0] || {}
+
+      dictionary = options[:dictionary]
+      dictionary ||= {} if options[:use_dictionary]
+
+      kopy = if dictionary
+               find_in_dictionary_or_dup(dictionary)
+             else
+               dup
+             end
+
+      options[:preprocessor].call(self, kopy) if options.key?(:preprocessor)
+
+      deep_exceptions = {}
+      if options[:except]
+        exceptions = Array.wrap(options[:except])
+        exceptions.each do |attribute|
+          dup_default_attribute_value_to(kopy, attribute, self) unless attribute.is_a?(Hash)
+        end
+        deep_exceptions = exceptions.select { |e| e.is_a?(Hash) }.inject({}) { |m, h| m.merge(h) }
+      end
+
+      deep_onlinesses = {}
+      if options[:only]
+        onlinesses = Array.wrap(options[:only])
+        object_attrs = kopy.attributes.keys.collect(&:to_sym)
+        exceptions = object_attrs - onlinesses
+        exceptions.each do |attribute|
+          dup_default_attribute_value_to(kopy, attribute, self) unless attribute.is_a?(Hash)
+        end
+        deep_onlinesses = onlinesses.select { |e| e.is_a?(Hash) }.inject({}) { |m, h| m.merge(h) }
+      end
+
+      kopy.instance_eval { extend ::DeepCloneable::SkipValidations } if options[:validate] == false
+
+      if options[:include]
+        normalized_includes_list(options[:include]).each do |association, conditions_or_deep_associations|
+          conditions = {}
+
+          if association.is_a? Hash
+            conditions_or_deep_associations = association[association.keys.first]
+            association = association.keys.first
+          end
+
+          case conditions_or_deep_associations
+          when Hash
+            conditions_or_deep_associations = conditions_or_deep_associations.dup
+            conditions[:if]     = conditions_or_deep_associations.delete(:if)     if conditions_or_deep_associations[:if]
+            conditions[:unless] = conditions_or_deep_associations.delete(:unless) if conditions_or_deep_associations[:unless]
+          when Array
+            conditions_or_deep_associations = conditions_or_deep_associations.map { |entry| entry.is_a?(Hash) ? entry.dup : entry }
+            conditions_or_deep_associations.each_with_index do |entry, index|
+              if entry.is_a?(Hash)
+                conditions[:if] = entry.delete(:if) if entry[:if]
+                conditions[:unless] = entry.delete(:unless) if entry[:unless]
+              end
+
+              conditions_or_deep_associations.delete_at(index) if entry.empty?
+            end
+          end
+
+          dup_options = {}
+          dup_options[:include] = conditions_or_deep_associations if conditions_or_deep_associations.present?
+          dup_options[:except] = deep_exceptions[association] if deep_exceptions[association]
+          dup_options[:only] = deep_onlinesses[association] if deep_onlinesses[association]
+          dup_options[:dictionary] = dictionary if dictionary
+
+          [:skip_missing_associations, :validate, :preprocessor, :postprocessor].each do |option|
+            dup_options[option] = options[option] if options.key?(option)
+          end
+
+          if (association_reflection = self.class.reflect_on_association(association))
+            association_type = association_reflection.macro
+            association_type = "#{association_type}_through" if association_reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
+
+            duped_object = send(
+              "dup_#{association_type}_association",
+              { :reflection => association_reflection, :association => association, :copy => kopy, :conditions => conditions, :dup_options => dup_options },
+              &block
+            )
+
+            kopy.send("#{association}=", duped_object)
+          elsif !options[:skip_missing_associations]
+            raise ::DeepCloneable::AssociationNotFoundException, "#{self.class}##{association}"
+          end
+        end
+      end
+
+      yield(self, kopy) if block
+      options[:postprocessor].call(self, kopy) if options.key?(:postprocessor)
+
+      kopy
+    end
+
+    protected
+
+    def find_in_dictionary_or_dup(dictionary, dup_on_miss = true)
+      tableized_class = self.class.name.tableize.to_sym
+      dictionary[tableized_class] ||= {}
+      dict_val = dictionary[tableized_class][self]
+      dict_val.nil? && dup_on_miss ? dictionary[tableized_class][self] = dup : dict_val
+    end
+
+    private
+
+    def dup_belongs_to_association(options, &block)
+      object = deep_cloneable_object_for(options[:association], options[:conditions])
+      object && object.deep_clone(options[:dup_options], &block)
+    end
+
+    def dup_has_one_association(options, &block)
+      dup_belongs_to_association options, &block
+    end
+
+    def dup_has_many_association(options, &block)
+      foreign_key = options[:reflection].foreign_key.to_s
+      reverse_association = find_reverse_association(options[:reflection], foreign_key, :belongs_to)
+      objects = deep_cloneable_objects_for(options[:association], options[:conditions])
+
+      objects.map do |object|
+        object = object.deep_clone(options[:dup_options], &block)
+        object.send("#{foreign_key}=", nil)
+        object.send("#{reverse_association.name}=", options[:copy]) if reverse_association
+        object
+      end
+    end
+
+    def dup_has_one_through_association(options, &block)
+      foreign_key = options[:reflection].through_reflection.foreign_key.to_s
+      reverse_association = find_reverse_association(options[:reflection], foreign_key, :has_one, :association_foreign_key)
+
+      object = deep_cloneable_object_for(options[:association], options[:conditions])
+      object && process_joined_object_for_deep_clone(object, options.merge(:reverse_association => reverse_association), &block)
+    end
+
+    def dup_has_many_through_association(options, &block)
+      foreign_key = options[:reflection].through_reflection.foreign_key.to_s
+      reverse_association = find_reverse_association(options[:reflection], foreign_key, :has_many, :association_foreign_key)
+
+      objects = deep_cloneable_objects_for(options[:association], options[:conditions])
+      objects.map { |object| process_joined_object_for_deep_clone(object, options.merge(:reverse_association => reverse_association), &block) }
+    end
+
+    def dup_has_and_belongs_to_many_association(options, &block)
+      foreign_key = options[:reflection].foreign_key.to_s
+      reverse_association = find_reverse_association(options[:reflection], foreign_key, :has_and_belongs_to_many, :association_foreign_key)
+
+      objects = deep_cloneable_objects_for(options[:association], options[:conditions])
+      objects.map { |object| process_joined_object_for_deep_clone(object, options.merge(:reverse_association => reverse_association), &block) }
+    end
+
+    def find_reverse_association(source_reflection, primary_key_name, macro, matcher = :foreign_key)
+      if source_reflection.inverse_of.present?
+        source_reflection.inverse_of
+      else
+        source_reflection.klass.reflect_on_all_associations.detect do |reflection|
+          reflection != source_reflection && (macro.nil? || reflection.macro == macro) && (reflection.send(matcher).to_s == primary_key_name)
+        end
+      end
+    end
+
+    def deep_cloneable_object_for(single_association, conditions)
+      object = send(single_association)
+      evaluate_conditions(object, conditions) ? object : nil
+    end
+
+    def deep_cloneable_objects_for(many_association, conditions)
+      send(many_association).select { |object| evaluate_conditions(object, conditions) }
+    end
+
+    def process_joined_object_for_deep_clone(object, options, &block)
+      if (dictionary = options[:dup_options][:dictionary]) && object.find_in_dictionary_or_dup(dictionary, false)
+        object = object.deep_clone(options[:dup_options], &block)
+      elsif options[:reverse_association]
+        object.send(options[:reverse_association].name).target << options[:copy]
+      end
+      object
+    end
+
+    def evaluate_conditions(object, conditions)
+      conditions.none? || (conditions[:if] && conditions[:if].call(object)) || (conditions[:unless] && !conditions[:unless].call(object))
+    end
+
+    def dup_default_attribute_value_to(kopy, attribute, origin)
+      kopy[attribute] = origin.class.column_defaults.dup[attribute.to_s]
+    end
+
+    def normalized_includes_list(includes)
+      list = []
+      Array(includes).each do |item|
+        if item.is_a?(Hash) && item.size > 1
+          item.each { |key, value| list << { key => value } }
+        else
+          list << item
+        end
+      end
+
+      list
+    end
+  end
+end

data/lib/deep_cloneable/skip_validations.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module DeepCloneable
+  module SkipValidations
+    def perform_validations(options = {})
+      options[:validate] = false
+      super(options)
+    end
+  end
+end

data/lib/deep_cloneable/version.rb

@@ -0,0 +1,3 @@
+module DeepCloneable
+  VERSION = '3.2.0'
+end

data/lib/deep_cloneable.rb

@@ -1,201 +1,18 @@
-require "active_record"
+# frozen_string_literal: true
 
-class ActiveRecord::Base
-  module DeepCloneable
+require 'active_record'
+require 'active_support/lazy_load_hooks'
+require 'active_support/core_ext/array/wrap'
 
-    # Deep dups an ActiveRecord model. See README.rdoc
-    def deep_clone *args, &block
-      options = args[0] || {}
+require 'deep_cloneable/association_not_found_exception'
+require 'deep_cloneable/skip_validations'
+require 'deep_cloneable/deep_clone'
 
-      dict = options[:dictionary]
-      dict ||= {} if options.delete(:use_dictionary)
-
-      kopy = unless dict
-        dup()
-      else
-        find_in_dict_or_dup(dict)
-      end
-
-      block.call(self, kopy) if block
-
-      deep_exceptions = {}
-      if options[:except]
-        exceptions = options[:except].nil? ? [] : [options[:except]].flatten
-        exceptions.each do |attribute|
-          dup_default_attribute_value_to(kopy, attribute, self) unless attribute.kind_of?(Hash)
-        end
-        deep_exceptions = exceptions.select{|e| e.kind_of?(Hash) }.inject({}){|m,h| m.merge(h) }
-      end
-
-      deep_onlinesses = {}
-      if options[:only]
-        onlinesses = options[:only].nil? ? [] : [options[:only]].flatten
-        object_attrs = kopy.attributes.keys.collect{ |s| s.to_sym }
-        exceptions = object_attrs - onlinesses
-        exceptions.each do |attribute|
-          dup_default_attribute_value_to(kopy, attribute, self) unless attribute.kind_of?(Hash)
-        end
-        deep_onlinesses = onlinesses.select{|e| e.kind_of?(Hash) }.inject({}){|m,h| m.merge(h) }
-      end
-
-      if options[:include]
-        normalized_includes_list(options[:include]).each do |association, conditions_or_deep_associations|
-          conditions = {}
-
-          if association.kind_of? Hash
-            conditions_or_deep_associations = association[association.keys.first]
-            association = association.keys.first
-          end
-
-          if conditions_or_deep_associations.kind_of?(Hash)
-            conditions_or_deep_associations = conditions_or_deep_associations.dup
-            conditions[:if]     = conditions_or_deep_associations.delete(:if)     if conditions_or_deep_associations[:if]
-            conditions[:unless] = conditions_or_deep_associations.delete(:unless) if conditions_or_deep_associations[:unless]
-          elsif conditions_or_deep_associations.kind_of?(Array)
-            conditions_or_deep_associations = conditions_or_deep_associations.dup
-            conditions_or_deep_associations.delete_if {|entry| conditions.merge!(entry) if entry.is_a?(Hash) && (entry.key?(:if) || entry.key?(:unless)) }
-          end
-
-          dup_options = {}
-          dup_options.merge!(:include => conditions_or_deep_associations) if conditions_or_deep_associations.present?
-          dup_options.merge!(:except => deep_exceptions[association]) if deep_exceptions[association]
-          dup_options.merge!(:only => deep_onlinesses[association]) if deep_onlinesses[association]
-          dup_options.merge!(:dictionary => dict) if dict
-          dup_options.merge!(:skip_missing_associations => options[:skip_missing_associations]) if options[:skip_missing_associations]
-
-          if association_reflection = self.class.reflect_on_association(association)
-            if options[:validate] == false
-              kopy.instance_eval do
-                # Force :validate => false on all saves.
-                def perform_validations(options={})
-                  options[:validate] = false
-                  super(options)
-                end
-              end
-            end
-
-            association_type = association_reflection.macro
-            association_type = "#{association_type}_through" if association_reflection.is_a?(ActiveRecord::Reflection::ThroughReflection)
-
-            duped_object = send(
-              "dup_#{association_type}_association",
-              { :reflection => association_reflection, :association => association, :copy => kopy, :conditions => conditions, :dup_options => dup_options },
-              &block
-            )
-
-            kopy.send("#{association}=", duped_object)
-          elsif !options[:skip_missing_associations]
-            raise AssociationNotFoundException.new("#{self.class}##{association}")
-          end
-        end
-      end
-
-      return kopy
-    end
-
-  protected
-
-    def find_in_dict_or_dup(dict, dup_on_miss = true)
-      tableized_class = self.class.name.tableize.to_sym
-      dict[tableized_class] ||= {}
-      dict_val = dict[tableized_class][self]
-      dict_val.nil? && dup_on_miss ? dict[tableized_class][self] = dup() : dict_val
-    end
-
-  private
-
-    def dup_default_attribute_value_to(kopy, attribute, origin)
-      kopy[attribute] = origin.class.column_defaults.dup[attribute.to_s]
-    end
-
-    def dup_belongs_to_association options, &block
-      object = self.send(options[:association])
-      object = nil if options[:conditions].any? && evaluate_conditions(object, options[:conditions])
-      object && object.deep_clone(options[:dup_options], &block)
-    end
-
-    def dup_has_one_association options, &block
-      dup_belongs_to_association options, &block
-    end
-
-    def dup_has_many_association options, &block
-      primary_key_name = options[:reflection].foreign_key.to_s
-
-      if options[:reflection].inverse_of.present?
-        reverse_association_name = options[:reflection].inverse_of.name
-      else
-        reverse_association_name = options[:reflection].klass.reflect_on_all_associations.detect do |reflection|
-          reflection.foreign_key.to_s == primary_key_name && reflection != options[:reflection]
-        end.try(:name)
-      end
-
-      objects = self.send(options[:association])
-      objects = objects.select{|object| evaluate_conditions(object, options[:conditions]) } if options[:conditions].any?
-
-      objects.collect do |object|
-        tmp = object.deep_clone(options[:dup_options], &block)
-        tmp.send("#{primary_key_name}=", nil)
-        tmp.send("#{reverse_association_name.to_s}=", options[:copy]) if reverse_association_name
-        tmp
-      end
-    end
-
-    def dup_has_many_through_association options, &block
-      dup_join_association(
-        options.merge(:macro => :has_many, :primary_key_name => options[:reflection].through_reflection.foreign_key.to_s),
-        &block)
-    end
-
-    def dup_has_and_belongs_to_many_association options, &block
-      dup_join_association(
-        options.merge(:macro => :has_and_belongs_to_many, :primary_key_name => options[:reflection].foreign_key.to_s),
-        &block)
-    end
-
-    def dup_join_association options, &block
-      if options[:reflection].inverse_of.present?
-        reverse_association_name = options[:reflection].inverse_of.name
-      else
-        reverse_association_name = options[:reflection].klass.reflect_on_all_associations.detect do |reflection|
-          (reflection.macro == options[:macro]) && (reflection.association_foreign_key.to_s == options[:primary_key_name])
-        end.try(:name)
-      end
-
-      objects = self.send(options[:association])
-      objects = objects.select{|object| evaluate_conditions(object, options[:conditions]) } if options[:conditions].any?
-
-      objects.collect do |object|
-        dict = options[:dup_options][:dictionary]
-        if(dict && object.find_in_dict_or_dup(dict, false))
-          object = object.deep_clone(options[:dup_options], &block)
-        else
-          object.send(reverse_association_name).target << options[:copy] if reverse_association_name
-        end
-        object
-      end
-    end
-
-    def evaluate_conditions object, conditions
-      (conditions[:if] && conditions[:if].call(object)) || (conditions[:unless] && !conditions[:unless].call(object))
-    end
-
-    def normalized_includes_list includes
-      list = []
-      Array(includes).each do |item|
-        if item.is_a?(Hash) && item.size > 1
-          item.each{|key, value| list << { key => value } }
-        else
-          list << item
-        end
-      end
-
-      list
-    end
-
-    class AssociationNotFoundException < StandardError; end
+module DeepCloneable
+end
 
-    ActiveRecord::Base.class_eval { protected :initialize_dup } if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 1
-  end
+ActiveSupport.on_load :active_record do
+  protected :initialize_dup if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 1
 
-  include DeepCloneable
+  include DeepCloneable::DeepClone
 end

data/readme.md

@@ -1,30 +1,40 @@
 # deep_cloneable
 
-[![Build Status](https://travis-ci.org/moiristo/deep_cloneable.svg?branch=master)](https://travis-ci.org/moiristo/deep_cloneable)
+![Build Status](https://github.com/moiristo/deep_cloneable/actions/workflows/ruby.yml/badge.svg)
 
 This gem gives every ActiveRecord::Base object the possibility to do a deep clone that includes user specified associations. It is a rails 3+ upgrade of the [deep_cloning plugin](http://github.com/openminds/deep_cloning).
 
 ## Requirements
 
-* Ruby 1.8.7, 1.9.2, 1.9.3, 2.0.0, 2.1.5, 2.2.2, 2.3.0, 2.4.4, 2.5.1 (tested)
-* Activerecord 3.1, 3.2, 4.0, 4.1, 4.2, 5.0, 5.1, 5.2 (tested)
-* Rails 2.x/3.0 users, please check out the 'rails2.x-3.0' branch
+- Ruby 2.3.0, 2.4.4, 2.5.5, 2.6.3, 2.7.5 (tested)
+- TruffleRuby 21.3.0
+- Activerecord 3.2, 4.0, 4.1, 4.2, 5.0, 5.1, 5.2, 6.0, 7.0 (tested)
+- Rails 2.x/3.0 users, please check out the 'rails2.x-3.0' branch
 
 ## Installation
 
-* Add deep_cloneable to your Gemfile:
+- Add deep_cloneable to your Gemfile:
 
 ```ruby
-gem 'deep_cloneable', '~> 2.3.2'
+gem 'deep_cloneable', '~> 3.2.0'
 ```
 
-## Upgrading from v1
+## Upgrade details
+
+### Upgrading from v2
+
+There are two breaking changes that you might need to pay attention to:
+
+- When using an optional block (see below), the block used to be evaluated before `deep_cloneable` had performed its changes (inclusions, exclusions, includes). In v3, the block is evaluated after all processing has been done, just before the copy is about to be returned.
+- When a defined association is not found, `deep_cloneable` raises an exception. The exception class has changed namespace: the class definition used to be `ActiveRecord::Base::DeepCloneable::AssociationNotFoundException` and this has changed to `DeepCloneable::AssociationNotFoundException`.
+
+### Upgrading from v1
 
 The `dup` method with arguments has been replaced in deep_cloneable 2 by the method `deep_clone`. Please update your sources accordingly.
 
 ## Usage
 
-The `deep_clone` method supports a couple options that can be specified by passing an options hash. Without options, the behaviour is the same as ActiveRecord's  [`dup`](http://apidock.com/rails/ActiveRecord/Core/dup) method.
+The `deep_clone` method supports a couple options that can be specified by passing an options hash. Without options, the behaviour is the same as ActiveRecord's [`dup`](http://apidock.com/rails/ActiveRecord/Core/dup) method.
 
 ### Association inclusion
 
@@ -76,6 +86,7 @@ pirate.deep_clone include: [ :mateys, { treasures: [ :matey, :gold_pieces ] } ],
 The `deep_clone` method supports both `except` and `only` for specifying which attributes should be duped:
 
 #### Exceptions
+
 ```ruby
 # Single exception
 pirate.deep_clone except: :name
@@ -88,6 +99,7 @@ pirate.deep_clone include: :parrot, except: [ :name, { parrot: [ :name ] } ]
 ```
 
 #### Inclusions
+
 ```ruby
 # Single attribute inclusion
 pirate.deep_clone only: :name
@@ -100,6 +112,19 @@ pirate.deep_clone include: :parrot, only: [ :name, { parrot: [ :name ] } ]
 
 ```
 
+### Pre- and postprocessor
+
+You can specify a pre- and/or a postprocessor to modify a duped object after duplication:
+
+```ruby
+pirate.deep_clone(include: :parrot, preprocessor: ->(original, kopy) { kopy.cloned_from_id = original.id if kopy.respond_to?(:cloned_from_id) })
+pirate.deep_clone(include: :parrot, postprocessor: ->(original, kopy) { kopy.cloned_from_id = original.id if kopy.respond_to?(:cloned_from_id) })
+```
+
+_Note_: Specifying a postprocessor is essentially the same as specifying an optional block (see below).
+
+_Note_: Using `deep_clone` with a processors will pass all associated objects that are being cloned to the processor, so be sure to check whether the object actually responds to your method of choice.
+
 ### Optional Block
 
 Pass a block to `deep_clone` to modify a duped object after duplication:
@@ -110,24 +135,94 @@ pirate.deep_clone include: :parrot do |original, kopy|
 end
 ```
 
-*Note*: The block is invoked before attributes are excluded.
+_Note_: Using `deep_clone` with a block will also pass the associated objects that are being cloned to the block, so be sure to check whether the object actually responds to your method of choice.
 
-*Note*: Using `deep_clone` with a block will also pass the associated objects that are being cloned to the block, so be sure to check whether the object actually responds to your method of choice.
+### Cloning models with files
 
-### Cloning models with files associated through Carrierwave
+#### Carrierwave
 
 If you are cloning models that have associated files through Carrierwave these will not get transferred automatically. To overcome the issue you need to explicitly set the file attribute.
 
 Easiest solution is to add the code in a clone block as described above.
+
 ```ruby
 pirate.deep_clone include: :parrot do |original, kopy|
   kopy.thumbnail = original.thumbnail
 end
 ```
 
+#### ActiveStorage
+
+For ActiveStorage, you have two options: you can either make a full copy, or share data blobs between two records.
+
+##### Full copy example
+
+```ruby
+# Rails 5.2, has_one_attached example 1
+pirate.deep_clone include: [:parrot, :avatar_attachment, :avatar_blob]
+
+# Rails 5.2, has_one_attached example 2
+pirate.deep_clone include: :parrot do |original, kopy|
+  if kopy.is_a?(Pirate) && original.avatar.attached?
+    attachment = original.avatar
+    kopy.avatar.attach \
+      :io           => StringIO.new(attachment.download),
+      :filename     => attachment.filename,
+      :content_type => attachment.content_type
+  end
+end
+
+# Rails 5.2, has_many_attached example 1 (attach one by one)
+pirate.deep_clone include: :parrot do |original, kopy|
+  if kopy.is_a?(Pirate) && original.crew_members_images.attached?
+    original.crew_members_images.each do |attachment|
+      kopy.crew_members_images.attach \
+        :io           => StringIO.new(attachment.download),
+        :filename     => attachment.filename,
+        :content_type => attachment.content_type
+    end
+  end
+end
+
+# Rails 5.2, has_many_attached example 2 (attach bulk)
+pirate.deep_clone include: :parrot do |original, kopy|
+  if kopy.is_a?(Pirate) && original.crew_members_images.attached?
+    all_attachments_arr = original.crew_members_images.map do |attachment|
+      {
+        :io           => StringIO.new(attachment.download),
+        :filename     => attachment.filename,
+        :content_type => attachment.content_type
+      }
+    end
+    kopy.crew_members_images.attach(all_attachments_arr) # attach all at once
+  end
+end
+
+# Rails 6
+pirate.deep_clone include: :parrot do |original, kopy|
+  if kopy.is_a?(Pirate) && original.avatar.attached?
+    original.avatar.open do |tempfile|
+      kopy.avatar.attach({
+        io: File.open(tempfile.path),
+        filename: original.avatar.blob.filename,
+        content_type: original.avatar.blob.content_type
+      })
+    end
+  end
+end
+```
+
+##### Shallow copy example
+
+```ruby
+pirate.deep_clone include: :parrot do |original, kopy|
+  kopy.avatar.attach(original.avatar.blob) if kopy.is_a?(Pirate) && original.avatar.attached?
+end
+```
+
 ### Skipping missing associations
 
-By default, deep_cloneable will throw a `ActiveRecord::Base::DeepCloneable::AssociationNotFoundException` error when an association cannot be found. You can also skip missing associations by specifying `skip_missing_associations` if needed, for example when you have associations on some (but not all) subclasses of an STI model:
+By default, deep_cloneable will throw a `DeepCloneable::AssociationNotFoundException` error when an association cannot be found. You can also skip missing associations by specifying `skip_missing_associations` if needed, for example when you have associations on some (but not all) subclasses of an STI model:
 
 ```ruby
 pirate.deep_clone include: [:parrot, :rum], skip_missing_associations: true
@@ -135,14 +230,14 @@ pirate.deep_clone include: [:parrot, :rum], skip_missing_associations: true
 
 ### Note on Patches/Pull Requests
 
-* Fork the project.
-* Make your feature addition or bug fix.
-* Add tests for it. This is important so I don't break it in a
+- Fork the project.
+- Make your feature addition or bug fix.
+- Add tests for it. This is important so I don't break it in a
   future version unintentionally.
-* Commit, do not mess with rakefile, version, or history.
+- Commit, do not mess with rakefile, version, or history.
   (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
-* Send me a pull request. Bonus points for topic branches.
+- Send me a pull request. Bonus points for topic branches.
 
 ### Copyright
 
-Copyright © 2018 Reinier de Lange. See LICENSE for details.
+Copyright © 2021 Reinier de Lange. See LICENSE for details.