deep_cloneable 1.4.0 → 3.2.1

data/deep_cloneable.gemspec

@@ -1,58 +1,21 @@
-# Generated by jeweler
-# DO NOT EDIT THIS FILE DIRECTLY
-# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
-# -*- encoding: utf-8 -*-
+# frozen_string_literal: true
 
-Gem::Specification.new do |s|
-  s.name = "deep_cloneable"
-  s.version = "1.4.0"
-
-  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Reinier de Lange"]
-  s.date = "2012-04-02"
-  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",
-    "Gemfile",
-    "Gemfile.lock",
-    "LICENSE",
-    "README.rdoc",
-    "Rakefile",
-    "VERSION",
-    "deep_cloneable.gemspec",
-    "init.rb",
-    "lib/deep_cloneable.rb",
-    "test/database.yml",
-    "test/schema.rb",
-    "test/test_deep_cloneable.rb",
-    "test/test_helper.rb"
-  ]
-  s.homepage = "http://github.com/moiristo/deep_cloneable"
-  s.require_paths = ["lib"]
-  s.rubygems_version = "1.8.21"
-  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 = 3
+$:.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<deep_cloneable>, [">= 0"])
-      s.add_runtime_dependency(%q<rails>, [">= 0"])
-      s.add_runtime_dependency(%q<jeweler>, [">= 0"])
-    else
-      s.add_dependency(%q<deep_cloneable>, [">= 0"])
-      s.add_dependency(%q<rails>, [">= 0"])
-      s.add_dependency(%q<jeweler>, [">= 0"])
-    end
-  else
-    s.add_dependency(%q<deep_cloneable>, [">= 0"])
-    s.add_dependency(%q<rails>, [">= 0"])
-    s.add_dependency(%q<jeweler>, [">= 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', '< 9'])
 end
-

data/init.rb

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

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

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.1'
+end

data/lib/deep_cloneable.rb

@@ -1,129 +1,18 @@
-class ActiveRecord::Base
-  module DeepCloneable
-    @@rails31 = ActiveRecord::VERSION::MAJOR >= 3 && ActiveRecord::VERSION::MINOR > 0
+# frozen_string_literal: true
 
-    # ActiveRecord::Base has its own dup method for Ruby 1.8.7. We have to
-    # redefine it and put it in a module so that we can override it in a
-    # module and call the original with super().
-    if @@rails31 and !Object.respond_to? :initialize_dup
-      ActiveRecord::Base.class_eval do
-        module Dup
-          def dup
-            copy = super
-            copy.initialize_dup(self)
-            copy
-          end
-        end
-        remove_method :dup
-        include Dup
-      end
-    end
+require 'active_record'
+require 'active_support/lazy_load_hooks'
+require 'active_support/core_ext/array/wrap'
 
-    # clones an ActiveRecord model. 
-    # if passed the :include option, it will deep clone the given associations
-    # if passed the :except option, it won't clone the given attributes
-    #
-    # === Usage:
-    # 
-    # ==== Cloning one single association
-    #    pirate.clone :include => :mateys
-    # 
-    # ==== Cloning multiple associations
-    #    pirate.clone :include => [:mateys, :treasures]
-    # 
-    # ==== Cloning really deep
-    #    pirate.clone :include => {:treasures => :gold_pieces}
-    # 
-    # ==== Cloning really deep with multiple associations
-    #    pirate.clone :include => [:mateys, {:treasures => :gold_pieces}]
-    #
-    # ==== Cloning really deep with multiple associations and a dictionary
-    #
-    # A dictionary ensures that models are not cloned multiple times when it is associated to nested models. 
-    # When using a dictionary, ensure recurring associations are cloned first:
-    #
-    #    pirate.clone :include => [:mateys, {:treasures => [:matey, :gold_pieces], :use_dictionary => true }]    
-    #
-    # If this is not an option for you, it is also possible to populate the dictionary manually in advance:
-    #
-    #    dict = { :mateys => {} }
-    #    pirate.mateys.each{|m| dict[:mateys][m] = m.clone }
-    #    pirate.clone :include => [:mateys, {:treasures => [:matey, :gold_pieces], :dictionary => dict }]    
-    #   
-    # ==== Cloning a model without an attribute
-    #    pirate.clone :except => :name
-    #  
-    # ==== Cloning a model without multiple attributes
-    #    pirate.clone :except => [:name, :nick_name]
-    #    
-    # ==== Cloning a model without an attribute or nested multiple attributes   
-    #    pirate.clone :include => :parrot, :except => [:name, { :parrot => [:name] }]
-    # 
-    define_method (@@rails31 ? :dup : :clone) do |*args, &block|
-      options = args[0] || {}
-      
-      dict = options[:dictionary]
-      dict ||= {} if options.delete(:use_dictionary)
-      
-      kopy = unless dict
-        super()
-      else
-        tableized_class = self.class.name.tableize.to_sym
-        dict[tableized_class] ||= {}
-        dict[tableized_class][self] ||= super()
-      end
+require 'deep_cloneable/association_not_found_exception'
+require 'deep_cloneable/skip_validations'
+require 'deep_cloneable/deep_clone'
 
-      block.call(self, kopy) if block
+module DeepCloneable
+end
 
-      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
-    
-      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
-          
-          opts = deep_associations.blank? ? {} : {:include => deep_associations}
-          opts.merge!(:except => deep_exceptions[association]) if deep_exceptions[association]
-          opts.merge!(:dictionary => dict) if dict
-        
-          association_reflection = self.class.reflect_on_association(association)
-          raise AssociationNotFoundException.new("#{self.class}##{association}") if association_reflection.nil?
-                    
-          cloned_object = case association_reflection.macro
-            when :belongs_to, :has_one
-              self.send(association) && self.send(association).send(__method__, opts, &block)
-            when :has_many, :has_and_belongs_to_many
-              primary_key_name = (@@rails31 ? association_reflection.foreign_key : association_reflection.primary_key_name).to_s
-              
-              reverse_association_name = association_reflection.klass.reflect_on_all_associations.detect do |a|
-                  a.send(@@rails31 ? :foreign_key : :primary_key_name).to_s == primary_key_name
-              end.try(:name)
-              
-              self.send(association).collect do |obj| 
-                tmp = obj.send(__method__, opts, &block)
-                tmp.send("#{primary_key_name}=", nil)                
-                tmp.send("#{reverse_association_name.to_s}=", kopy) if reverse_association_name
-                tmp
-              end
-            end
-          kopy.send("#{association}=", cloned_object)
-        end
-      end
+ActiveSupport.on_load :active_record do
+  protected :initialize_dup if ActiveRecord::VERSION::MAJOR == 3 && ActiveRecord::VERSION::MINOR == 1
 
-      return kopy
-    end
-    
-    class AssociationNotFoundException < StandardError; end    
-  end
-  
-  include DeepCloneable
-end
+  include DeepCloneable::DeepClone
+end