deep_cloneable 2.3.2 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0ff9ad4fd2ffe0fcf8495c86114392032080de83d306325f9932e7752459be90
-  data.tar.gz: fcba14c118c7a7b2144f0d25f61cbf4c8a55098e92930a260284aba2eacd8f1b
+  metadata.gz: c9bc79180e45ac09676614be579f12550f6e9e4e123a320bb42ce7675dfe95eb
+  data.tar.gz: 39db7d4d43ee2dee821d16dce99feb1fcd70b20878d6bb37b9283b51213ed9b3
 SHA512:
-  metadata.gz: d390f573c9730d707e841aa7ef658a39ac70de947af7aa9d750e98f0e9087e835288f471c9ed9599b783e3cd9726ed62c7e7c3f1986f6c92e3044f51f74575b2
-  data.tar.gz: ecc8d7314a3d745d619de830b479931d646924682939cf387f24b5557061703ba6644d1623c56f6b21b3d82237e9188546bfe8b6f54b186cb7f738e338e2f286
+  metadata.gz: f4908868fbfd325c6953c8c68fbce7ce935349c9eedf206579b3f6433bfa1073f1f2c2c10cff81ce2ccd212c6db921d0be904784062318d98d1fd69d03eb21f4
+  data.tar.gz: f8fd74ad2f5c95d9cecbd5df6450b9bf551a0aba708096b6cfbbee777d3ba43e6b1f64447c8cac03c1fdacf8867880a7ac8f2f2297fe17471b9881ea88097afb

data/.rubocop.yml

@@ -0,0 +1,20 @@
+Metrics:
+  Enabled: false
+
+Security/YAMLLoad:
+  Enabled: false
+
+Style/ClassAndModuleChildren:
+  Enabled: false
+
+Style/Documentation:
+  Enabled: false
+
+Style/HashSyntax:
+  EnforcedStyle: hash_rockets
+
+Style/Lambda:
+  EnforcedStyle: lambda
+
+Style/SymbolArray:
+  EnforcedStyle: brackets

data/.travis.yml

@@ -15,8 +15,8 @@ rvm:
   - 2.5.1
 
 before_install:
-  - gem update --system
-  - gem install bundler
+  - gem update --system 2.7.8
+  - gem install bundler -v 1.17.3
 
 gemfile:
   - gemfiles/3.1.gemfile

data/CHANGELOG.md

@@ -5,6 +5,16 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
+
+## [2.4.0] - 2019-01-10
+### Added
+- Support `has_one` and `has_one - through`
+### Changed
+- Lint code via Rubocop
+- Refactor code to improve readability
+- Use HTTPS in the gemspec website URL
+
+## [2.3.2] - 2018-04-11
 ### Added
 - Support for Ruby 2.4 and 2.5
 - Support for Rails 5.1 and 5.2
@@ -156,7 +166,9 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ### Fixed
 - Convert existing code to a gem
 
-[Unreleased]: https://github.com/moiristo/deep_cloneable/compare/v2.3.1...HEAD
+[Unreleased]: https://github.com/moiristo/deep_cloneable/compare/v2.4.0...HEAD
+[2.4.0]: https://github.com/moiristo/deep_cloneable/compare/v2.3.2...v2.4.0
+[2.3.2]: https://github.com/moiristo/deep_cloneable/compare/v2.3.1...v2.3.2
 [2.3.1]: https://github.com/moiristo/deep_cloneable/compare/v2.3.0...v2.3.1
 [2.3.0]: https://github.com/moiristo/deep_cloneable/compare/v2.2.2...v2.3.0
 [2.2.2]: https://github.com/moiristo/deep_cloneable/compare/v2.2.1...v2.2.2

data/Gemfile

@@ -2,14 +2,14 @@ source 'http://rubygems.org'
 
 gem 'activerecord', '>= 3.1.0', '< 6'
 
+gem 'git', '~> 1.2.9', :group => :test
 gem 'highline', '~> 1.6.0', :group => :test
-gem 'rake', '~> 10.4', :group => :test
 gem 'rack', '~> 1.6', :group => :test
-gem 'git', '~> 1.2.9', :group => :test
+gem 'rake', '~> 10.4', :group => :test
 
-gem 'minitest', :group => :test
 gem 'appraisal', :group => :test
-gem 'sqlite3', :group => :test
-gem 'rdoc', '>= 2.4.2', '< 6', :group => :test
-gem 'nokogiri', '~> 1.5.0', :group => :test
 gem 'jeweler', :group => :test
+gem 'minitest', :group => :test
+gem 'nokogiri', '~> 1.5.0', :group => :test
+gem 'rdoc', '>= 2.4.2', '< 6', :group => :test
+gem 'sqlite3', :group => :test

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2018 Reinier de Lange
+Copyright (c) 2019 Reinier de Lange
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/VERSION

@@ -1 +1 @@
-2.3.2
+2.4.0

data/deep_cloneable.gemspec

@@ -2,16 +2,16 @@
 # DO NOT EDIT THIS FILE DIRECTLY
 # Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
 # -*- encoding: utf-8 -*-
-# stub: deep_cloneable 2.3.2 ruby lib
+# stub: deep_cloneable 2.4.0 ruby lib
 
 Gem::Specification.new do |s|
   s.name = "deep_cloneable".freeze
-  s.version = "2.3.2"
+  s.version = "2.4.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0".freeze) if s.respond_to? :required_rubygems_version=
   s.require_paths = ["lib".freeze]
   s.authors = ["Reinier de Lange".freeze]
-  s.date = "2018-04-11"
+  s.date = "2019-01-10"
   s.description = "Extends the functionality of ActiveRecord::Base#dup to perform a deep clone that includes user specified associations. ".freeze
   s.email = "rjdelange@icloud.com".freeze
   s.extra_rdoc_files = [
@@ -19,6 +19,7 @@ Gem::Specification.new do |s|
   ]
   s.files = [
     ".document",
+    ".rubocop.yml",
     ".travis.yml",
     "Appraisals",
     "CHANGELOG.md",

data/lib/deep_cloneable.rb

@@ -1,73 +1,72 @@
-require "active_record"
+require 'active_record'
 
 class ActiveRecord::Base
   module DeepCloneable
-
     # Deep dups an ActiveRecord model. See README.rdoc
-    def deep_clone *args, &block
+    def deep_clone(*args, &block)
       options = args[0] || {}
 
-      dict = options[:dictionary]
-      dict ||= {} if options.delete(:use_dictionary)
+      dictionary = options[:dictionary]
+      dictionary ||= {} if options.delete(:use_dictionary)
 
-      kopy = unless dict
-        dup()
-      else
-        find_in_dict_or_dup(dict)
-      end
+      kopy = if dictionary
+               find_in_dictionary_or_dup(dictionary)
+             else
+               dup
+             end
 
-      block.call(self, kopy) if block
+      yield(self, kopy) if block
 
       deep_exceptions = {}
       if options[:except]
-        exceptions = options[:except].nil? ? [] : [options[:except]].flatten
+        exceptions = array_wrap(options[:except])
         exceptions.each do |attribute|
-          dup_default_attribute_value_to(kopy, attribute, self) unless attribute.kind_of?(Hash)
+          dup_default_attribute_value_to(kopy, attribute, self) unless attribute.is_a?(Hash)
         end
-        deep_exceptions = exceptions.select{|e| e.kind_of?(Hash) }.inject({}){|m,h| m.merge(h) }
+        deep_exceptions = exceptions.select { |e| e.is_a?(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 }
+        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.kind_of?(Hash)
+          dup_default_attribute_value_to(kopy, attribute, self) unless attribute.is_a?(Hash)
         end
-        deep_onlinesses = onlinesses.select{|e| e.kind_of?(Hash) }.inject({}){|m,h| m.merge(h) }
+        deep_onlinesses = onlinesses.select { |e| e.is_a?(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
+          if association.is_a? Hash
             conditions_or_deep_associations = association[association.keys.first]
             association = association.keys.first
           end
 
-          if conditions_or_deep_associations.kind_of?(Hash)
+          if conditions_or_deep_associations.is_a?(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)
+          elsif conditions_or_deep_associations.is_a?(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)) }
+            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]
+          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
+          dup_options[:skip_missing_associations] = options[:skip_missing_associations] if options[:skip_missing_associations]
 
-          if association_reflection = self.class.reflect_on_association(association)
+          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={})
+                def perform_validations(options = {})
                   options[:validate] = false
                   super(options)
                 end
@@ -85,105 +84,112 @@ class ActiveRecord::Base
 
             kopy.send("#{association}=", duped_object)
           elsif !options[:skip_missing_associations]
-            raise AssociationNotFoundException.new("#{self.class}##{association}")
+            raise AssociationNotFoundException, "#{self.class}##{association}"
           end
         end
       end
 
-      return kopy
+      kopy
     end
 
-  protected
+    protected
 
-    def find_in_dict_or_dup(dict, dup_on_miss = true)
+    def find_in_dictionary_or_dup(dictionary, 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
+      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_default_attribute_value_to(kopy, attribute, origin)
-      kopy[attribute] = origin.class.column_defaults.dup[attribute.to_s]
-    end
+    private
 
-    def dup_belongs_to_association options, &block
-      object = self.send(options[:association])
-      object = nil if options[:conditions].any? && evaluate_conditions(object, options[:conditions])
+    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
+    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
+    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])
 
-      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)
+      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
 
-      objects = self.send(options[:association])
-      objects = objects.select{|object| evaluate_conditions(object, options[:conditions]) } if options[:conditions].any?
+    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)
 
-      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
+      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
-      dup_join_association(
-        options.merge(:macro => :has_many, :primary_key_name => options[:reflection].through_reflection.foreign_key.to_s),
-        &block)
+    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
-      dup_join_association(
-        options.merge(:macro => :has_and_belongs_to_many, :primary_key_name => options[:reflection].foreign_key.to_s),
-        &block)
+    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 dup_join_association options, &block
-      if options[:reflection].inverse_of.present?
-        reverse_association_name = options[:reflection].inverse_of.name
+    def find_reverse_association(source_reflection, primary_key_name, macro, matcher = :foreign_key)
+      if source_reflection.inverse_of.present?
+        source_reflection.inverse_of
       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)
+        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
 
-      objects = self.send(options[:association])
-      objects = objects.select{|object| evaluate_conditions(object, options[:conditions]) } if options[:conditions].any?
+    def deep_cloneable_object_for(single_association, conditions)
+      object = send(single_association)
+      evaluate_conditions(object, conditions) && object
+    end
 
-      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
+    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 evaluate_conditions object, conditions
-      (conditions[:if] && conditions[:if].call(object)) || (conditions[:unless] && !conditions[:unless].call(object))
+    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
+    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 } }
+          item.each { |key, value| list << { key => value } }
         else
           list << item
         end
@@ -192,6 +198,14 @@ class ActiveRecord::Base
       list
     end
 
+    def array_wrap(object)
+      if object.respond_to?(:to_ary)
+        object.to_ary || [object]
+      else
+        [object]
+      end
+    end
+
     class AssociationNotFoundException < StandardError; end
 
     ActiveRecord::Base.class_eval { protected :initialize_dup } if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 1

data/readme.md

@@ -15,7 +15,7 @@ This gem gives every ActiveRecord::Base object the possibility to do a deep clon
 * Add deep_cloneable to your Gemfile:
 
 ```ruby
-gem 'deep_cloneable', '~> 2.3.2'
+gem 'deep_cloneable', '~> 2.4.0'
 ```
 
 ## Upgrading from v1
@@ -114,7 +114,9 @@ end
 
 *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 associated through Carrierwave
+### Cloning models with files
+
+#### 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.
 
@@ -125,6 +127,35 @@ pirate.deep_clone include: :parrot do |original, kopy|
 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
+pirate.deep_clone include: :parrot do |original, kopy|
+  if kopy.is_a?(Pirate) && original.avatar.attached?
+    ActiveStorage::Downloader.new(original.avatar).download_blob_to_tempfile do |tempfile|
+      kopy.avatar.attach({
+        io: tempfile,
+        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:
@@ -145,4 +176,4 @@ pirate.deep_clone include: [:parrot, :rum], skip_missing_associations: true
 
 ### Copyright
 
-Copyright © 2018 Reinier de Lange. See LICENSE for details.
+Copyright © 2019 Reinier de Lange. See LICENSE for details.

data/test/models.rb

@@ -26,14 +26,12 @@ module Animal
     has_many :birds
   end
 
-
   class Ownership < ActiveRecord::Base
     belongs_to :human
     belongs_to :chicken
 
     validates_uniqueness_of :chicken_id, :scope => :human_id
   end
-
 end
 
 class GoldPiece < ActiveRecord::Base;   belongs_to :treasure  end
@@ -89,7 +87,7 @@ class ChildWithValidation < ActiveRecord::Base
 end
 
 class ParentWithValidation < ActiveRecord::Base
-  has_many :children, :class_name => 'ChildWithValidation'
+  has_many :children, :class_name => 'ChildWithValidation', :foreign_key => 'parent_id'
   validates :name, :presence => true
 end
 
@@ -126,6 +124,7 @@ end
 class Contractor < ActiveRecord::Base
   belongs_to :building
   has_and_belongs_to_many :apartments
+  has_one :contract
 end
 
 class User < ActiveRecord::Base
@@ -140,3 +139,13 @@ end
 class Product < ActiveRecord::Base
   belongs_to :order
 end
+
+class Contract < ActiveRecord::Base
+  belongs_to :contractor
+  belongs_to :organization
+end
+
+class Organization < ActiveRecord::Base
+  has_one :contract
+  has_one :contractor, :through => :contract
+end

data/test/schema.rb

@@ -90,7 +90,7 @@ ActiveRecord::Schema.define(:version => 1) do
 
   create_table :child_with_validations, :force => true do |t|
     t.column :name, :string
-    t.column :parent_with_validation_id, :integer
+    t.column :parent_id, :integer
   end
 
   create_table :parts, :force => true do |t|
@@ -143,4 +143,14 @@ ActiveRecord::Schema.define(:version => 1) do
     t.column :name, :string
     t.column :order_id, :integer
   end
+
+  create_table :organizations, :force => true do |t|
+    t.column :name, :string
+  end
+
+  create_table :contracts, :force => true do |t|
+    t.column :number, :string
+    t.column :contractor_id, :integer
+    t.column :organization_id, :integer
+  end
 end

data/test/test_deep_cloneable.rb

@@ -1,7 +1,6 @@
 require 'test_helper'
 
 class TestDeepCloneable < MiniTest::Unit::TestCase
-
   def setup
     @jack  = Pirate.create(:name => 'Jack Sparrow', :nick_name => 'Captain Jack', :age => 30)
     @polly = Parrot.create(:name => 'Polly', :age => 2, :pirate => @jack)
@@ -84,7 +83,7 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
   end
 
   def test_deep_include_association
-    deep_clone = @jack.deep_clone(:include => {:treasures => :gold_pieces})
+    deep_clone = @jack.deep_clone(:include => { :treasures => :gold_pieces })
     assert deep_clone.new_record?
     assert deep_clone.save
     assert_equal 1, deep_clone.treasures.size
@@ -110,7 +109,7 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
   end
 
   def test_multiple_and_deep_include_association
-    deep_clone = @jack.deep_clone(:include => {:treasures => :gold_pieces, :mateys => {}})
+    deep_clone = @jack.deep_clone(:include => { :treasures => :gold_pieces, :mateys => {} })
     assert deep_clone.new_record?
     assert deep_clone.save
     assert_equal 1, deep_clone.treasures.size
@@ -119,7 +118,7 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
   end
 
   def test_multiple_and_deep_include_association_with_array
-    deep_clone = @jack.deep_clone(:include => [{:treasures => :gold_pieces}, :mateys])
+    deep_clone = @jack.deep_clone(:include => [{ :treasures => :gold_pieces }, :mateys])
     assert deep_clone.new_record?
     assert deep_clone.save
     assert_equal 1, deep_clone.treasures.size
@@ -128,7 +127,7 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
   end
 
   def test_multiple_and_deep_include_association_with_array_and_multikey_hash
-    deep_clone = @jack.deep_clone(:include => [:parrot, {:treasures => :gold_pieces, :mateys => {}}])
+    deep_clone = @jack.deep_clone(:include => [:parrot, { :treasures => :gold_pieces, :mateys => {} }])
     assert deep_clone.new_record?
     assert deep_clone.save
     assert_equal 1, deep_clone.treasures.size
@@ -153,6 +152,16 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
     assert_nil deep_clone.parrot.name
   end
 
+  def test_should_pass_nested_exception_with_hash_value
+    deep_clone = @jack.deep_clone(:include => :parrot, :except => { :parrot => [:name] })
+    assert deep_clone.new_record?
+    assert deep_clone.save
+    refute_equal deep_clone.parrot, @jack.parrot
+    assert_equal deep_clone.parrot.age, @jack.parrot.age
+    refute_nil @jack.parrot.name
+    assert_nil deep_clone.parrot.name
+  end
+
   def test_should_pass_nested_onlinesses
     deep_clone = @jack.deep_clone(:include => :parrot, :only => [:name, { :parrot => [:name] }])
     assert deep_clone.new_record?
@@ -163,6 +172,16 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
     assert_nil deep_clone.parrot.age
   end
 
+  def test_should_pass_nested_onliness_with_hash_value
+    deep_clone = @jack.deep_clone(:include => :parrot, :only => { :parrot => [:name] })
+    assert deep_clone.new_record?
+    assert deep_clone.piastres, []
+    assert deep_clone.save
+    refute_equal deep_clone.parrot, @jack.parrot
+    assert_equal deep_clone.parrot.name, @jack.parrot.name
+    assert_nil deep_clone.parrot.age
+  end
+
   def test_should_not_double_deep_clone_when_using_dictionary
     current_matey_count = Matey.count
     deep_clone = @jack.deep_clone(:include => [:mateys, { :treasures => :matey }], :use_dictionary => true)
@@ -176,7 +195,7 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
     current_matey_count = Matey.count
 
     dict = { :mateys => {} }
-    @jack.mateys.each{|m| dict[:mateys][m] = m.deep_clone }
+    @jack.mateys.each { |m| dict[:mateys][m] = m.deep_clone }
 
     deep_clone = @jack.deep_clone(:include => [:mateys, { :treasures => :matey }], :dictionary => dict)
     assert deep_clone.new_record?
@@ -186,7 +205,7 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
   end
 
   def test_should_support_ar_class_under_module
-    @human = Animal::Human.create :name => "Michael"
+    @human = Animal::Human.create :name => 'Michael'
     @pig = Animal::Pig.create :human => @human, :name => 'big pig'
 
     deep_clone_human = @human.deep_clone(:include => [:pigs])
@@ -194,18 +213,18 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
     assert deep_clone_human.save
     assert_equal 1, deep_clone_human.pigs.count
 
-    @human2 = Animal::Human.create :name => "John"
+    @human2 = Animal::Human.create :name => 'John'
     @pig2 = @human2.pigs.create :name => 'small pig'
 
-    deep_clone_human_2 = @human.deep_clone(:include => [:pigs])
-    assert deep_clone_human_2.new_record?
-    assert deep_clone_human_2.save
-    assert_equal 1, deep_clone_human_2.pigs.count
+    deep_clone_human2 = @human.deep_clone(:include => [:pigs])
+    assert deep_clone_human2.new_record?
+    assert deep_clone_human2.save
+    assert_equal 1, deep_clone_human2.pigs.count
   end
 
   def test_should_deep_clone_many_to_many_associations
-    @human = Animal::Human.create :name => "Michael"
-    @human2 = Animal::Human.create :name => "Jack"
+    @human = Animal::Human.create :name => 'Michael'
+    @human2 = Animal::Human.create :name => 'Jack'
     @chicken1 = Animal::Chicken.create :name => 'Chick1'
     @chicken2 = Animal::Chicken.create :name => 'Chick2'
     @human.chickens << [@chicken1, @chicken2]
@@ -219,8 +238,8 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
 
   def test_should_skip_missing_associations
     @earth = Animal::Planet.create :name => 'Earth'
-    @human = Animal::Human.create :name => "Michael"
-    @chicken = Animal::Chicken.create :name => 'Chick', :humans => [@human], :planet => @earth, :humans => [@human]
+    @human = Animal::Human.create :name => 'Michael'
+    @chicken = Animal::Chicken.create :name => 'Chick', :humans => [@human], :planet => @earth
     @dove = Animal::Dove.create :name => 'Dovey', :planet => @earth
 
     assert_raises ActiveRecord::Base::DeepCloneable::AssociationNotFoundException do
@@ -229,7 +248,7 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
 
     deep_clone_earth = @earth.deep_clone(:include => { :birds => :ownerships }, :skip_missing_associations => true)
     assert_equal 2, deep_clone_earth.birds.size
-    assert deep_clone_earth.birds.detect{|bird| bird.is_a?(Animal::Chicken) }.ownerships.any?
+    assert deep_clone_earth.birds.detect { |bird| bird.is_a?(Animal::Chicken) }.ownerships.any?
   end
 
   def test_should_deep_clone_with_block
@@ -244,8 +263,8 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
   end
 
   def test_should_deep_clone_habtm_associations
-    @person1 = Person.create :name => "Bill"
-    @person2 = Person.create :name => "Ted"
+    @person1 = Person.create :name => 'Bill'
+    @person2 = Person.create :name => 'Ted'
     @car1 = Car.create :name => 'Mustang'
     @car2 = Car.create :name => 'Camaro'
     @person1.cars << [@car1, @car2]
@@ -269,7 +288,7 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
 
   def test_should_deep_clone_habtm_associations_with_missing_reverse_association
     @coin = Coin.create :value => 1
-    @person = Person.create :name => "Bill"
+    @person = Person.create :name => 'Bill'
     @coin.people << @person
 
     deep_clone = @coin.deep_clone :include => :people
@@ -286,7 +305,7 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
     deep_clone = student.deep_clone :include => { :student_assignments => :subject }
     deep_clone.save # Subjects will have been set after save
     assert_equal 2, deep_clone.subjects.size
-    [subject1, subject2].each{|subject| assert !deep_clone.subjects.include?(subject) }
+    [subject1, subject2].each { |subject| assert !deep_clone.subjects.include?(subject) }
   end
 
   def test_parent_validations_run_on_save_after_clone
@@ -328,7 +347,7 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
     assert deep_clone_parent.new_record?
     assert !deep_clone_parent.valid?
     assert !deep_clone_parent.children.first.valid?
-    assert_equal deep_clone_parent.errors.messages, :children => ["is invalid"]
+    assert_equal deep_clone_parent.errors.messages, :children => ['is invalid']
   end
 
   def test_child_validations_run_on_save_after_clone_without_validation
@@ -342,13 +361,13 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
     assert !deep_clone_parent.new_record?
     assert !deep_clone_parent.valid?
     assert !deep_clone_parent.children.first.valid?
-    assert_equal deep_clone_parent.errors.messages, :children => ["is invalid"]
+    assert_equal deep_clone_parent.errors.messages, :children => ['is invalid']
   end
 
   def test_self_join_has_many
     parent_part = Part.create(:name => 'Parent')
-    child1 = Part.create(:name => 'Child 1', :parent_part_id => parent_part.id)
-    child2 = Part.create(:name => 'Child 2', :parent_part_id => parent_part.id)
+    Part.create(:name => 'Child 1', :parent_part_id => parent_part.id)
+    Part.create(:name => 'Child 2', :parent_part_id => parent_part.id)
 
     deep_clone_part = parent_part.deep_clone :include => :child_parts
     assert deep_clone_part.save
@@ -362,7 +381,16 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
 
     deep_clone = student.deep_clone :include => :subjects
     assert_equal 2, deep_clone.subjects.size
-    assert_equal [[student, deep_clone],[student, deep_clone]], deep_clone.subjects.map{|subject| subject.students }
+    assert_equal [[student, deep_clone], [student, deep_clone]], deep_clone.subjects.map(&:students)
+  end
+
+  def test_should_include_has_one_through_associations
+    organization = Organization.create(:name => 'organization')
+    contractor = Contractor.create(:name => 'contractor')
+    Contract.create(:number => 12_345, :contractor => contractor, :organization => organization)
+
+    deep_clone = organization.deep_clone(:include => :contractor)
+    assert_equal organization.contractor, deep_clone.contractor
   end
 
   def test_should_deep_clone_unsaved_objects
@@ -380,14 +408,14 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
     subject2 = Subject.create(:name => 'subject 2')
     student = Student.create(:name => 'Parent', :subjects => [subject1, subject2])
 
-    deep_clone = student.deep_clone :include => { :subjects => { :if => lambda{|subject| subject.name == 'subject 2' } } }
+    deep_clone = student.deep_clone :include => { :subjects => { :if => lambda { |subject| subject.name == 'subject 2' } } }
     assert_equal 1, deep_clone.subjects.size
     assert_equal 'subject 2', deep_clone.subjects.first.name
 
     deep_clone = @jack.deep_clone(:include => {
-      :treasures => { :gold_pieces => { :unless => lambda{|piece| piece.is_a?(Parrot) } } },
-      :mateys => { :if => lambda{|matey| matey.is_a?(GoldPiece) } }
-    })
+                                    :treasures => { :gold_pieces => { :unless => lambda { |piece| piece.is_a?(Parrot) } } },
+                                    :mateys => { :if => lambda { |matey| matey.is_a?(GoldPiece) } }
+                                  })
 
     assert deep_clone.new_record?
     assert deep_clone.save
@@ -401,21 +429,21 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
     subject2 = Subject.create(:name => 'subject 2')
     student = Student.create(:name => 'Parent', :subjects => [subject1, subject2])
 
-    deep_clone = student.deep_clone(:include => [:subjects => [:if => lambda{|subject| false }] ])
+    deep_clone = student.deep_clone(:include => [:subjects => [:if => lambda { |_subject| false }]])
     assert deep_clone.subjects.none?
 
-    deep_clone = student.deep_clone(:include => [:subjects => [:if => lambda{|subject| true }] ])
+    deep_clone = student.deep_clone(:include => [:subjects => [:if => lambda { |_subject| true }]])
     assert_equal 2, deep_clone.subjects.size
   end
 
   def test_should_reject_copies_if_conditionals_are_passed_with_associations
-    deep_clone = @ship.deep_clone(:include => [:pirates => [:treasures, :mateys, { :unless => lambda {|pirate| pirate.name == 'Jack Sparrow'} }]])
+    deep_clone = @ship.deep_clone(:include => [:pirates => [:treasures, :mateys, { :unless => lambda { |pirate| pirate.name == 'Jack Sparrow' } }]])
 
     assert deep_clone.new_record?
     assert deep_clone.save
     assert_equal 0, deep_clone.pirates.size
 
-    deep_clone = @ship.deep_clone(:include => [:pirates => [:treasures, :mateys, { :if => lambda {|pirate| pirate.name == 'Jack Sparrow'} }]])
+    deep_clone = @ship.deep_clone(:include => [:pirates => [:treasures, :mateys, { :if => lambda { |pirate| pirate.name == 'Jack Sparrow' } }]])
     assert deep_clone.new_record?
     assert deep_clone.save
     assert_equal 1, deep_clone.pirates.size
@@ -430,36 +458,36 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
     @order2.products << [@product1, @product2]
     @user.orders << [@order1, @order2]
 
-    deep_clone = @user.deep_clone(:include => [:orders => [:products => [{ :unless => lambda {|product| product.name == 'Ink' }}]]])
+    deep_clone = @user.deep_clone(:include => [:orders => [:products => [{ :unless => lambda { |product| product.name == 'Ink' } }]]])
 
     assert deep_clone.new_record?
     assert deep_clone.save
     assert_equal 1, deep_clone.orders.second.products.size
 
-    deep_clone = @user.deep_clone(:include => [:orders => [:products => [{ :if => lambda {|product| product.name == 'Ink'}}]]])
+    deep_clone = @user.deep_clone(:include => [:orders => [:products => [{ :if => lambda { |product| product.name == 'Ink' } }]]])
     assert deep_clone.new_record?
     assert deep_clone.save
     assert_equal 1, deep_clone.orders.second.products.size
   end
 
   def test_should_find_in_dict_for_habtm
-    apt = Apartment.create(:number => "101")
-    contractor = Contractor.create(:name => "contractor", :apartments => [apt])
+    apt = Apartment.create(:number => '101')
+    contractor = Contractor.create(:name => 'contractor', :apartments => [apt])
 
     apt.contractors = [contractor]
     apt.save!
 
-    building = Building.create(:name => "Tall Building", :contractors => [contractor], :apartments => [apt])
+    building = Building.create(:name => 'Tall Building', :contractors => [contractor], :apartments => [apt])
 
     deep_clone = building.deep_clone(:include => [
-      :apartments,
-      {
-        :contractors => [
-          :apartments
-        ]
-      }
-    ],
-    :use_dictionary => true)
+                                       :apartments,
+                                       {
+                                         :contractors => [
+                                           :apartments
+                                         ]
+                                       }
+                                     ],
+                                     :use_dictionary => true)
 
     deep_clone.save!
 
@@ -472,5 +500,4 @@ class TestDeepCloneable < MiniTest::Unit::TestCase
     assert_nil deep_clone.name
     refute deep_clone.name_changed?
   end
-
 end

data/test/test_helper.rb

@@ -13,24 +13,24 @@ require 'active_record'
 I18n.enforce_available_locales = true
 
 def load_schema
-  config = YAML::load(IO.read(File.dirname(__FILE__) + '/database.yml'))
+  config = YAML.load(IO.read(File.dirname(__FILE__) + '/database.yml'))
 
-  if defined?(ActiveSupport::BufferedLogger)
-    ActiveRecord::Base.logger = ActiveSupport::BufferedLogger.new(File.dirname(__FILE__) + "/debug.log")
-  else
-    ActiveRecord::Base.logger = ActiveSupport::Logger.new(File.dirname(__FILE__) + "/debug.log")
-  end
+  ActiveRecord::Base.logger = if defined?(ActiveSupport::BufferedLogger)
+                                ActiveSupport::BufferedLogger.new(File.dirname(__FILE__) + '/debug.log')
+                              else
+                                ActiveSupport::Logger.new(File.dirname(__FILE__) + '/debug.log')
+                              end
 
   db_adapter = ENV['DB']
   db_adapter ||= 'sqlite3'
 
   if db_adapter.nil?
-    raise "No DB Adapter selected. Pass the DB= option to pick one, or install Sqlite or Sqlite3."
+    raise 'No DB Adapter selected. Pass the DB= option to pick one, or install Sqlite or Sqlite3.'
   end
   ActiveRecord::Base.establish_connection(config[db_adapter])
-  load(File.dirname(__FILE__) + "/schema.rb")
+  load(File.dirname(__FILE__) + '/schema.rb')
 end
 
 load_schema
 require File.dirname(__FILE__) + '/../init.rb'
-require 'models'
+require 'models'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: deep_cloneable
 version: !ruby/object:Gem::Version
-  version: 2.3.2
+  version: 2.4.0
 platform: ruby
 authors:
 - Reinier de Lange
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-11 00:00:00.000000000 Z
+date: 2019-01-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activerecord
@@ -39,6 +39,7 @@ extra_rdoc_files:
 - LICENSE
 files:
 - ".document"
+- ".rubocop.yml"
 - ".travis.yml"
 - Appraisals
 - CHANGELOG.md