deep_cloneable 2.3.0 → 3.1.0

data/gemfiles/5.0.gemfile.lock

@@ -1,89 +0,0 @@
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activemodel (5.0.0.1)
-      activesupport (= 5.0.0.1)
-    activerecord (5.0.0.1)
-      activemodel (= 5.0.0.1)
-      activesupport (= 5.0.0.1)
-      arel (~> 7.0)
-    activesupport (5.0.0.1)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (~> 0.7)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-    addressable (2.4.0)
-    appraisal (2.1.0)
-      bundler
-      rake
-      thor (>= 0.14.0)
-    arel (7.1.1)
-    builder (3.2.2)
-    concurrent-ruby (1.0.2)
-    descendants_tracker (0.0.4)
-      thread_safe (~> 0.3, >= 0.3.1)
-    faraday (0.9.2)
-      multipart-post (>= 1.2, < 3)
-    git (1.2.9.1)
-    github_api (0.14.5)
-      addressable (~> 2.4.0)
-      descendants_tracker (~> 0.0.4)
-      faraday (~> 0.8, < 0.10)
-      hashie (>= 3.4)
-      oauth2 (~> 1.0)
-    hashie (3.4.6)
-    highline (1.6.21)
-    i18n (0.7.0)
-    jeweler (2.1.1)
-      builder
-      bundler (>= 1.0)
-      git (>= 1.2.5)
-      github_api
-      highline (>= 1.6.15)
-      nokogiri (>= 1.5.10)
-      rake
-      rdoc
-      semver
-    json (1.8.3)
-    jwt (1.5.4)
-    minitest (5.9.0)
-    multi_json (1.12.1)
-    multi_xml (0.5.5)
-    multipart-post (2.0.0)
-    nokogiri (1.5.11)
-    oauth2 (1.2.0)
-      faraday (>= 0.8, < 0.10)
-      jwt (~> 1.0)
-      multi_json (~> 1.3)
-      multi_xml (~> 0.5)
-      rack (>= 1.2, < 3)
-    rack (1.6.4)
-    rake (10.5.0)
-    rdoc (4.2.2)
-      json (~> 1.4)
-    semver (1.0.1)
-    sqlite3 (1.3.11)
-    thor (0.19.1)
-    thread_safe (0.3.5)
-    tzinfo (1.2.2)
-      thread_safe (~> 0.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  activerecord (~> 5.0.0)
-  appraisal
-  git (~> 1.2.9)
-  highline (~> 1.6.0)
-  i18n (~> 0.7.0)
-  jeweler
-  minitest
-  nokogiri (~> 1.5.0)
-  rack (~> 1.6)
-  rake (~> 10.4)
-  rdoc (>= 2.4.2)
-  sqlite3
-
-BUNDLED WITH
-   1.11.2

data/test/database.yml

@@ -1,6 +0,0 @@
-sqlite: 
-  adapter: sqlite
-  database: ":memory:"
-sqlite3:
-  adapter: sqlite3
-  database: ":memory:"

data/test/models.rb

@@ -1,129 +0,0 @@
-module Animal
-  class Human < ActiveRecord::Base
-    has_many :pigs
-
-    has_many :ownerships
-    has_many :chickens, :through => :ownerships
-  end
-
-  class Pig < ActiveRecord::Base
-    belongs_to :human
-  end
-
-  class Bird < ActiveRecord::Base
-    belongs_to :planet
-  end
-
-  class Chicken < Bird
-    has_many :ownerships
-    has_many :humans, :through => :ownerships
-  end
-
-  class Dove < Bird
-  end
-
-  class Planet < ActiveRecord::Base
-    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
-class Matey < ActiveRecord::Base;       belongs_to :pirate    end
-class BattleShip < ActiveRecord::Base;  has_many   :pirates, :as => :ship end
-
-class Parrot < ActiveRecord::Base
-  belongs_to :pirate
-  has_many :parrot_cages, :foreign_key => :owner_id, :inverse_of => :parrot, :class_name => 'Cage'
-  attr_accessor :cloned_from_id
-end
-
-class Cage < ActiveRecord::Base
-  belongs_to :parrot, :foreign_key => :owner_id, :inverse_of => :parrot_cages
-  belongs_to :pirate, :foreign_key => :owner_id, :inverse_of => :pirate_cages
-end
-
-class Pirate < ActiveRecord::Base
-  belongs_to :ship, :polymorphic => true
-
-  has_many :mateys
-  has_many :treasures, :foreign_key => 'owner'
-  has_many :gold_pieces, :through => :treasures
-  has_one :parrot
-  has_many :pirate_cages, :inverse_of => :pirate, :foreign_key => :owner_id, :class_name => 'Cage'
-
-  serialize :piastres
-
-  attr_accessor :cloned_from_id
-end
-
-class Treasure < ActiveRecord::Base
-  belongs_to :pirate, :foreign_key => :owner
-  belongs_to :matey
-  has_many :gold_pieces
-end
-
-class Person < ActiveRecord::Base
-  has_and_belongs_to_many :cars
-end
-
-class Car < ActiveRecord::Base
-  has_and_belongs_to_many :people
-end
-
-class Coin < ActiveRecord::Base
-  has_and_belongs_to_many :people
-end
-
-class ChildWithValidation < ActiveRecord::Base
-  belongs_to :parent, :class_name => 'ParentWithValidation'
-  validates :name, :presence => true
-end
-
-class ParentWithValidation < ActiveRecord::Base
-  has_many :children, :class_name => 'ChildWithValidation'
-  validates :name, :presence => true
-end
-
-class Part < ActiveRecord::Base
-  # belongs_to :parent_part, :class_name => 'Part'
-  has_many :child_parts, :class_name => 'Part', :foreign_key => 'parent_part_id'
-end
-
-class Student < ActiveRecord::Base
-  has_many :student_assignments, :dependent => :destroy
-  has_many :subjects, :through => :student_assignments
-end
-
-class Subject < ActiveRecord::Base
-  has_many :student_assignments, :dependent => :destroy
-  has_many :students, :through => :student_assignments
-end
-
-class StudentAssignment < ActiveRecord::Base
-  belongs_to :subject
-  belongs_to :student
-end
-
-class Building < ActiveRecord::Base
-  has_many :apartments
-  has_many :contractors
-end
-
-class Apartment < ActiveRecord::Base
-  belongs_to :building
-  has_and_belongs_to_many :contractors
-end
-
-class Contractor < ActiveRecord::Base
-  belongs_to :building
-  has_and_belongs_to_many :apartments
-end

data/test/schema.rb

@@ -1,132 +0,0 @@
-ActiveRecord::Schema.define(:version => 1) do
-  create_table :pirates, :force => true do |t|
-    t.column :name, :string
-    t.column :nick_name, :string, :default => 'no nickname'
-    t.column :age, :string
-    t.column :ship_id, :integer
-    t.column :ship_type, :string
-    t.column :piastres, :text, :default => [].to_yaml
-  end
-
-  create_table :parrots, :force => true do |t|
-    t.column :name, :string
-    t.column :age, :integer
-    t.column :pirate_id, :integer
-  end
-
-  create_table :mateys, :force => true do |t|
-    t.column :name, :string
-    t.column :pirate_id, :integer
-  end
-
-  create_table :treasures, :force => true do |t|
-    t.column :found_at, :string
-    t.column :owner, :integer
-    t.column :matey_id, :integer
-  end
-
-  create_table :cages, :force => true do |t|
-    t.column :name, :string
-    t.column :owner_id, :integer
-  end
-
-  create_table :gold_pieces, :force => true do |t|
-    t.column :treasure_id, :integer
-  end
-
-  create_table :battle_ships, :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table :pigs, :force => true do |t|
-    t.column :name, :string
-    t.column :human_id, :integer
-  end
-
-  create_table :humen, :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table :planets, :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table :birds, :force => true do |t|
-    t.column :name, :string
-    t.column :type, :string
-    t.column :planet_id, :integer
-  end
-
-  create_table :ownerships, :force => true do |t|
-    t.column :human_id, :integer
-    t.column :chicken_id, :integer
-  end
-
-  create_table :cars, :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table :coins, :force => true do |t|
-    t.column :value, :integer
-  end
-
-  create_table :people, :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table :cars_people, :id => false, :force => true do |t|
-    t.column :car_id, :integer
-    t.column :person_id, :integer
-  end
-
-  create_table :coins_people, :id => false, :force => true do |t|
-    t.column :coin_id, :integer
-    t.column :person_id, :integer
-  end
-
-  create_table :parent_with_validations, :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table :child_with_validations, :force => true do |t|
-    t.column :name, :string
-    t.column :parent_with_validation_id, :integer
-  end
-
-  create_table :parts, :force => true do |t|
-    t.column :name, :string
-    t.column :parent_part_id, :integer
-  end
-
-  create_table :students, :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table :subjects, :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table :student_assignments, :force => true do |t|
-    t.column :student_id, :integer
-    t.column :subject_id, :integer
-  end
-
-  create_table :buildings, :force => true do |t|
-    t.column :name, :string
-  end
-
-  create_table :apartments, :force => true do |t|
-    t.column :number, :string
-    t.column :building_id, :integer
-  end
-
-  create_table :contractors, :force => true do |t|
-    t.column :name, :string
-    t.column :building_id, :integer
-  end
-
-  create_table :apartments_contractors, :force => true do |t|
-    t.column :apartment_id, :integer
-    t.column :contractor_id, :integer
-  end
-end

data/test/test_deep_cloneable.rb

@@ -1,455 +0,0 @@
-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)
-    @john = Matey.create(:name => 'John', :pirate => @jack)
-    @treasure = Treasure.create(:found_at => 'Isla del Muerte', :pirate => @jack, :matey => @john)
-    @gold_piece = GoldPiece.create(:treasure => @treasure)
-    @ship = BattleShip.create(:name => 'Black Pearl', :pirates => [@jack])
-  end
-
-  def test_single_deep_clone_exception
-    deep_clone = @jack.deep_clone(:except => :name)
-    assert deep_clone.new_record?
-    assert deep_clone.save
-    assert_equal @jack.name, @jack.deep_clone.name
-    assert_nil deep_clone.name
-    assert_equal @jack.nick_name, deep_clone.nick_name
-  end
-
-  def test_multiple_deep_clone_exception
-    deep_clone = @jack.deep_clone(:except => [:name, :nick_name])
-    assert deep_clone.new_record?
-    assert deep_clone.save
-    assert_nil deep_clone.name
-    assert_equal 'no nickname', deep_clone.nick_name
-    assert_equal @jack.age, deep_clone.age
-  end
-
-  def test_single_deep_clone_onliness
-    deep_clone = @jack.deep_clone(:only => :name)
-    assert deep_clone.new_record?
-    assert deep_clone.piastres, []
-    assert deep_clone.save
-    assert_equal @jack.name, deep_clone.name
-    assert_equal 'no nickname', deep_clone.nick_name
-    assert_nil deep_clone.age
-    assert_nil deep_clone.ship_id
-    assert_nil deep_clone.ship_type
-  end
-
-  def test_multiple_deep_clone_onliness
-    deep_clone = @jack.deep_clone(:only => [:name, :nick_name])
-    assert deep_clone.new_record?
-    assert deep_clone.piastres, []
-    assert deep_clone.save
-    assert_equal @jack.name, deep_clone.name
-    assert_equal @jack.nick_name, deep_clone.nick_name
-    assert_nil deep_clone.age
-    assert_nil deep_clone.ship_id
-    assert_nil deep_clone.ship_type
-  end
-
-  def test_single_include_association
-    deep_clone = @jack.deep_clone(:include => :mateys)
-    assert deep_clone.new_record?
-    assert deep_clone.save
-    assert_equal 1, deep_clone.mateys.size
-  end
-
-  def test_single_include_belongs_to_polymorphic_association
-    deep_clone = @jack.deep_clone(:include => :ship)
-    assert deep_clone.new_record?
-    assert deep_clone.save
-    refute_nil deep_clone.ship
-    refute_equal @jack.ship, deep_clone.ship
-  end
-
-  def test_single_include_has_many_polymorphic_association
-    deep_clone = @ship.deep_clone(:include => :pirates)
-    assert deep_clone.new_record?
-    assert deep_clone.save
-    assert deep_clone.pirates.any?
-  end
-
-  def test_multiple_include_association
-    deep_clone = @jack.deep_clone(:include => [:mateys, :treasures])
-    assert deep_clone.new_record?
-    assert deep_clone.save
-    assert_equal 1, deep_clone.mateys.size
-    assert_equal 1, deep_clone.treasures.size
-  end
-
-  def test_deep_include_association
-    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
-    assert_equal 1, deep_clone.gold_pieces.size
-  end
-
-  def test_include_association_assignments
-    deep_clone = @jack.deep_clone(:include => :treasures)
-    assert deep_clone.new_record?
-
-    deep_clone.treasures.each do |treasure|
-      assert_equal deep_clone, treasure.pirate
-    end
-  end
-
-  def test_include_association_assignments_with_inverse_of
-    @jack.pirate_cages.build
-    deep_clone = @jack.deep_clone(:include => :pirate_cages)
-    assert deep_clone.new_record?
-    deep_clone.pirate_cages.each do |cage|
-      assert_equal deep_clone, cage.pirate
-    end
-  end
-
-  def test_multiple_and_deep_include_association
-    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
-    assert_equal 1, deep_clone.gold_pieces.size
-    assert_equal 1, deep_clone.mateys.size
-  end
-
-  def test_multiple_and_deep_include_association_with_array
-    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
-    assert_equal 1, deep_clone.gold_pieces.size
-    assert_equal 1, deep_clone.mateys.size
-  end
-  
-  def test_multiple_and_deep_include_association_with_array_and_multikey_hash
-    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
-    assert_equal 1, deep_clone.gold_pieces.size
-    assert_equal 1, deep_clone.mateys.size
-  end  
-
-  def test_with_belongs_to_relation
-    deep_clone = @jack.deep_clone(:include => :parrot)
-    assert deep_clone.new_record?
-    assert deep_clone.save
-    refute_equal deep_clone.parrot, @jack.parrot
-  end
-
-  def test_should_pass_nested_exceptions
-    deep_clone = @jack.deep_clone(:include => :parrot, :except => [:name, { :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?
-    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)
-    assert deep_clone.new_record?
-    deep_clone.save!
-
-    assert_equal current_matey_count + 1, Matey.count
-  end
-
-  def test_should_not_double_deep_clone_when_using_manual_dictionary
-    current_matey_count = Matey.count
-
-    dict = { :mateys => {} }
-    @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?
-    deep_clone.save!
-
-    assert_equal current_matey_count + 1, Matey.count
-  end
-
-  def test_should_support_ar_class_under_module
-    @human = Animal::Human.create :name => "Michael"
-    @pig = Animal::Pig.create :human => @human, :name => 'big pig'
-
-    deep_clone_human = @human.deep_clone(:include => [:pigs])
-    assert deep_clone_human.new_record?
-    assert deep_clone_human.save
-    assert_equal 1, deep_clone_human.pigs.count
-
-    @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
-  end
-
-  def test_should_deep_clone_many_to_many_associations
-    @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]
-    @human2.chickens << [@chicken1, @chicken2]
-
-    deep_clone_human = @human.deep_clone(:include => :ownerships)
-    assert deep_clone_human.new_record?
-    assert deep_clone_human.save
-    assert_equal 2, deep_clone_human.chickens.count
-  end
-
-  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]
-    @dove = Animal::Dove.create :name => 'Dovey', :planet => @earth
-
-    assert_raises ActiveRecord::Base::DeepCloneable::AssociationNotFoundException do
-      @earth.deep_clone(:include => { :birds => :ownerships })
-    end
-
-    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?
-  end
-
-  def test_should_deep_clone_with_block
-    deep_clone = @jack.deep_clone(:include => :parrot) do |original, kopy|
-      kopy.cloned_from_id = original.id
-    end
-
-    assert deep_clone.new_record?
-    assert deep_clone.save
-    assert_equal @jack.id, deep_clone.cloned_from_id
-    assert_equal @jack.parrot.id, deep_clone.parrot.cloned_from_id
-  end
-
-  def test_should_deep_clone_habtm_associations
-    @person1 = Person.create :name => "Bill"
-    @person2 = Person.create :name => "Ted"
-    @car1 = Car.create :name => 'Mustang'
-    @car2 = Car.create :name => 'Camaro'
-    @person1.cars << [@car1, @car2]
-    @person2.cars << [@car1, @car2]
-
-    deep_clone_person = @person1.deep_clone :include => :cars
-
-    assert deep_clone_person.new_record?
-    assert_equal [@person1, @person2, deep_clone_person], @car1.people
-    assert_equal [@person1, @person2, deep_clone_person], @car2.people
-
-    assert deep_clone_person.save
-
-    # did NOT deep_clone the Car instances
-    assert_equal 2, Car.all.count
-
-    # did deep_clone the correct join table rows
-    assert_equal @person1.cars, deep_clone_person.cars
-    assert_equal 2, deep_clone_person.cars.count
-  end
-
-  def test_should_deep_clone_habtm_associations_with_missing_reverse_association
-    @coin = Coin.create :value => 1
-    @person = Person.create :name => "Bill"
-    @coin.people << @person
-
-    deep_clone = @coin.deep_clone :include => :people
-    assert deep_clone.new_record?
-    assert_equal [@person], @coin.people
-    assert deep_clone.save
-  end
-
-  def test_should_deep_clone_joined_association
-    subject1 = Subject.create(:name => 'subject 1')
-    subject2 = Subject.create(:name => 'subject 2')
-    student = Student.create(:name => 'Parent', :subjects => [subject1, subject2])
-
-    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) }
-  end
-
-  def test_parent_validations_run_on_save_after_clone
-    child = ChildWithValidation.create :name => 'Jimmy'
-    parent = ParentWithValidation.new :children => [child]
-    parent.save :validate => false
-
-    deep_clone_parent = parent.deep_clone :include => :children
-
-    assert !deep_clone_parent.save
-    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, :name => ["can't be blank"]
-  end
-
-  def test_parent_validations_dont_run_on_save_after_clone
-    child = ChildWithValidation.create :name => 'Jimmy'
-    parent = ParentWithValidation.new :children => [child]
-    parent.save :validate => false
-
-    deep_clone_parent = parent.deep_clone :include => :children, :validate => false
-
-    assert deep_clone_parent.save
-    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, :name => ["can't be blank"]
-  end
-
-  def test_child_validations_run_on_save_after_clone
-    child = ChildWithValidation.new
-    child.save :validate => false
-    parent = ParentWithValidation.create :name => 'John', :children => [child]
-
-    deep_clone_parent = parent.deep_clone :include => :children
-
-    assert !deep_clone_parent.save
-    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"]
-  end
-
-  def test_child_validations_run_on_save_after_clone_without_validation
-    child = ChildWithValidation.new
-    child.save :validate => false
-    parent = ParentWithValidation.create :name => 'John', :children => [child]
-
-    deep_clone_parent = parent.deep_clone :include => :children, :validate => false
-
-    assert deep_clone_parent.save
-    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"]
-  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)
-
-    deep_clone_part = parent_part.deep_clone :include => :child_parts
-    assert deep_clone_part.save
-    assert_equal 2, deep_clone_part.child_parts.size
-  end
-
-  def test_should_include_has_many_through_associations
-    subject1 = Subject.create(:name => 'subject 1')
-    subject2 = Subject.create(:name => 'subject 2')
-    student = Student.create(:name => 'Parent', :subjects => [subject1, subject2])
-
-    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 }
-  end
-
-  def test_should_deep_clone_unsaved_objects
-    jack = Pirate.new(:name => 'Jack Sparrow', :nick_name => 'Captain Jack', :age => 30)
-    jack.mateys.build(:name => 'John')
-
-    deep_clone = jack.deep_clone(:include => :mateys)
-    assert deep_clone.new_record?
-    assert_equal 1, deep_clone.mateys.size
-    assert_equal 'John', deep_clone.mateys.first.name
-  end
-
-  def test_should_reject_copies_if_conditionals_are_passed
-    subject1 = Subject.create(:name => 'subject 1')
-    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' } } }
-    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) } }
-    })
-
-    assert deep_clone.new_record?
-    assert deep_clone.save
-    assert_equal 1, deep_clone.treasures.size
-    assert_equal 1, deep_clone.gold_pieces.size
-    assert_equal 0, deep_clone.mateys.size
-  end
-
-  def test_should_properly_read_conditions_in_arrays
-    subject1 = Subject.create(:name => 'subject 1')
-    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 }] ])
-    assert deep_clone.subjects.none?
-
-    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'} }]])
-
-    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'} }]])
-    assert deep_clone.new_record?
-    assert deep_clone.save
-    assert_equal 1, deep_clone.pirates.size
-  end
-
-  def test_should_find_in_dict_for_habtm
-    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])
-
-    deep_clone = building.deep_clone(:include => [
-      :apartments,
-      {
-        :contractors => [
-          :apartments
-        ]
-      }
-    ],
-    :use_dictionary => true)
-
-    deep_clone.save!
-
-    assert_equal deep_clone.contractors.first.apartments.first.id, deep_clone.apartments.first.id
-    assert_equal deep_clone.apartments.first.contractors.first.id, deep_clone.contractors.first.id
-  end
-
-  def test_should_not_make_attributes_dirty_for_exceptions
-    deep_clone = @jack.deep_clone(:except => :name)
-    assert_nil deep_clone.name
-    refute deep_clone.name_changed?
-  end
-  
-end