deep_cloneable 2.0.2 → 3.1.0

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Reinier de Lange
+Copyright (c) 2021 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/Rakefile

@@ -1,24 +1,10 @@
+# frozen_string_literal: true
+
 require 'rubygems'
 require 'bundler/setup'
 require 'appraisal'
-
-begin
-  require 'jeweler'
-  Jeweler::Tasks.new do |gem|
-    gem.name = "deep_cloneable"
-    gem.summary = %Q{This gem gives every ActiveRecord::Base object the possibility to do a deep clone.}
-    gem.description = %Q{Extends the functionality of ActiveRecord::Base#clone to perform a deep clone that includes user specified associations. }
-    gem.email = "r.j.delange@nedforce.nl"
-    gem.homepage = "http://github.com/moiristo/deep_cloneable"
-    gem.authors = ["Reinier de Lange"]
-    # gem is a Gem::Specification... see http://www.rubygems.org/read/chapter/20 for additional settings
-  end
-  Jeweler::GemcutterTasks.new
-rescue LoadError
-  puts "Jeweler (or a dependency) not available. Install it with: gem install jeweler"
-end
-
 require 'rake/testtask'
+
 Rake::TestTask.new(:test) do |test|
   test.libs << 'lib' << 'test'
   test.pattern = 'test/**/test_*.rb'
@@ -29,7 +15,7 @@ task :default => :test
 
 require 'rdoc/task'
 Rake::RDocTask.new do |rdoc|
-  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+  version = File.exist?('VERSION') ? File.read('VERSION') : ''
 
   rdoc.rdoc_dir = 'rdoc'
   rdoc.title = "deep_cloneable #{version}"

data/deep_cloneable.gemspec

@@ -1,66 +1,21 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
-# stub: deep_cloneable 2.0.2 ruby lib
+# frozen_string_literal: true
 
-Gem::Specification.new do |s|
-  s.name = "deep_cloneable"
-  s.version = "2.0.2"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.require_paths = ["lib"]
-  s.authors = ["Reinier de Lange"]
-  s.date = "2014-12-17"
-  s.description = "Extends the functionality of ActiveRecord::Base#clone to perform a deep clone that includes user specified associations. "
-  s.email = "r.j.delange@nedforce.nl"
-  s.extra_rdoc_files = [
-    "LICENSE",
-    "README.rdoc"
-  ]
-  s.files = [
-    ".document",
-    ".travis.yml",
-    "Appraisals",
-    "Gemfile",
-    "Gemfile.lock",
-    "LICENSE",
-    "README.rdoc",
-    "Rakefile",
-    "VERSION",
-    "deep_cloneable.gemspec",
-    "gemfiles/3.1.gemfile",
-    "gemfiles/3.1.gemfile.lock",
-    "gemfiles/3.2.gemfile",
-    "gemfiles/3.2.gemfile.lock",
-    "gemfiles/4.0.gemfile",
-    "gemfiles/4.0.gemfile.lock",
-    "gemfiles/4.1.gemfile",
-    "gemfiles/4.1.gemfile.lock",
-    "gemfiles/4.2.gemfile",
-    "gemfiles/4.2.gemfile.lock",
-    "init.rb",
-    "lib/deep_cloneable.rb",
-    "test/database.yml",
-    "test/models.rb",
-    "test/schema.rb",
-    "test/test_deep_cloneable.rb",
-    "test/test_helper.rb"
-  ]
-  s.homepage = "http://github.com/moiristo/deep_cloneable"
-  s.rubygems_version = "2.4.2"
-  s.summary = "This gem gives every ActiveRecord::Base object the possibility to do a deep clone."
-
-  if s.respond_to? :specification_version then
-    s.specification_version = 4
+$:.unshift File.expand_path('../lib', __FILE__)
+require 'deep_cloneable/version'
 
-    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
-      s.add_runtime_dependency(%q<activerecord>, ["< 5.0.0", ">= 3.1.0"])
-    else
-      s.add_dependency(%q<activerecord>, ["< 5.0.0", ">= 3.1.0"])
-    end
-  else
-    s.add_dependency(%q<activerecord>, ["< 5.0.0", ">= 3.1.0"])
-  end
+Gem::Specification.new do |s|
+  s.name = 'deep_cloneable'
+  s.version = DeepCloneable::VERSION
+  s.authors = ['Reinier de Lange']
+  s.description = 'Extends the functionality of ActiveRecord::Base#dup to perform a deep clone that includes user specified associations. '
+  s.summary = 'This gem gives every ActiveRecord::Base object the possibility to do a deep clone.'
+  s.email = 'rjdelange@icloud.com'
+  s.extra_rdoc_files = ['LICENSE']
+  s.files = Dir.glob('{bin/*,lib/**/*,[A-Z]*}')
+  s.homepage = 'https://github.com/moiristo/deep_cloneable'
+  s.licenses = ['MIT']
+  s.platform = Gem::Platform::RUBY
+  s.required_ruby_version = '>= 1.9.3'
+  s.require_paths = ['lib']
+  s.add_runtime_dependency('activerecord', ['>= 3.1.0', '< 7'])
 end
-

data/init.rb

@@ -1 +1,3 @@
-require 'deep_cloneable'
+# frozen_string_literal: true
+
+require 'deep_cloneable'

data/lib/deep_cloneable.rb

@@ -1,136 +1,18 @@
-class ActiveRecord::Base
-  module DeepCloneable
+# frozen_string_literal: true
 
-    # Deep dups an ActiveRecord model. See README.rdoc
-    def deep_clone *args, &block
-      options = args[0] || {}
+require 'active_record'
+require 'active_support/lazy_load_hooks'
+require 'active_support/core_ext/array/wrap'
 
-      dict = options[:dictionary]
-      dict ||= {} if options.delete(:use_dictionary)
+require 'deep_cloneable/association_not_found_exception'
+require 'deep_cloneable/skip_validations'
+require 'deep_cloneable/deep_clone'
 
-      kopy = unless dict
-        dup()
-      else
-        tableized_class = self.class.name.tableize.to_sym
-        dict[tableized_class] ||= {}
-        dict[tableized_class][self] ||= dup()
-      end
-
-      block.call(self, kopy) if block
-
-      deep_exceptions = {}
-      if options[:except]
-        exceptions = options[:except].nil? ? [] : [options[:except]].flatten
-        exceptions.each do |attribute|
-          kopy.send(:write_attribute, attribute, self.class.column_defaults.dup[attribute.to_s]) 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|
-          kopy.send(:write_attribute, attribute, self.class.column_defaults.dup[attribute.to_s]) 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]
-        Array(options[:include]).each do |association, deep_associations|
-          if (association.kind_of? Hash)
-            deep_associations = association[association.keys.first]
-            association = association.keys.first
-          end
-
-          dup_options = deep_associations.blank? ? {} : {:include => deep_associations}
-          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
-
-          association_reflection = self.class.reflect_on_association(association)
-          raise AssociationNotFoundException.new("#{self.class}##{association}") if association_reflection.nil?
-
-          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)
-
-          cloned_object = send(
-            "dup_#{association_type}_association",
-            { :reflection => association_reflection, :association => association, :copy => kopy, :dup_options => dup_options },
-            &block
-          )
-
-          kopy.send("#{association}=", cloned_object)
-        end
-      end
-
-      return kopy
-    end
-
-  private
-
-    def dup_belongs_to_association options, &block
-      self.send(options[:association]) && self.send(options[:association]).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
-
-      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)
-
-      self.send(options[:association]).collect do |obj|
-        tmp = obj.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
-      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)
-
-      self.send(options[:association]).collect do |obj|
-        obj.send(reverse_association_name).target << options[:copy] if reverse_association_name
-        obj
-      end
-    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/lib/deep_cloneable/association_not_found_exception.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module DeepCloneable
+  class AssociationNotFoundException < StandardError
+  end
+end

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