acts_as_brand_new_copy 1.0.0

data/.gitignore

@@ -0,0 +1,19 @@
+._*
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+db/*sqlite3

data/.travis.yml

@@ -0,0 +1,5 @@
+language: ruby
+rvm:
+  - "1.8.7"
+  - "1.9.3"
+script: bundle exec rspec spec

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+#source 'http://ruby.taobao.org'
+
+# Specify your gem's dependencies in acts_as_brand_new_copy.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 BenCao
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,149 @@
+# acts_as_brand_new_copy
+
+[![Gem Version](https://badge.fury.io/rb/acts_as_brand_new_copy.png)](http://badge.fury.io/rb/acts_as_brand_new_copy)
+[![Build Status](https://travis-ci.org/bencao/acts_as_brand_new_copy.png)](https://travis-ci.org/bencao/acts_as_brand_new_copy)
+
+Copy an active record with its associated records are not easy.
+
+For example, if we have defined these classes:
+
+```ruby
+class StudentTeacherAssignment < ActiveRecord::Base
+  belongs_to :teacher
+  belongs_to :student
+end
+
+class GradeTeacherAssignment < ActiveRecord::Base
+  belongs_to :grade
+  belongs_to :teacher
+end
+
+class GradeStudentAssignment < ActiveRecord::Base
+  belongs_to :grade
+  belongs_to :student
+end
+
+class Grade < ActiveRecord::Base
+  has_and_belongs_to_many :teachers, :join_table => ::GradeTeacherAssignment.table_name
+  has_and_belongs_to_many :students, :join_table => ::GradeStudentAssignment.table_name
+end
+
+class Teacher < ActiveRecord::Base
+  has_many :student_teacher_assignments
+  has_many :students,
+    :through => :student_teacher_assignments,
+    :source  => :student
+end
+
+class Student < ActiveRecord::Base
+  has_many :student_teacher_assignments
+  has_many :teachers,
+    :through => :student_teacher_assignments,
+    :source  => :teacher
+  has_many :scores
+end
+
+class Score < ActiveRecord::Base
+  belongs_to :student
+end
+```
+
+Can you copy a grade with its teachers and students to another grade in a few lines of code?
+To me, it's no, consequently acts_as_brand_new_copy was born.
+
+## Usage
+
+### copy an active record with its associations
+
+```ruby
+# copy student itself, return the id for copied student
+copy_id = @student.brand_new_copy
+
+# copy student with their scores
+copy_id = @student.brand_new_copy({:associations => [:scores]})
+
+# copy the whole grade and all the relationships between grade to students, teachers to students
+# NOTE here shows the convenience bought by this gem, we've ensured that a same student won't be copied twice!
+copy_id = @grade.brand_new_copy({:associations => [{:teachers => [:students]}, :students]})
+```
+
+### i'd like to do some modifications to records during copy process
+
+Don't worry, we've already supported that!
+
+```
+# prefix student name with a 'Copy Of ' during copy
+# a callback defined as a class method is needed
+Student.class_eval do
+  def self.update_name_when_copy(hash_origin, hash_copy, full_context)
+    hash_copy['name'] = 'Copy of ' + hash_origin['name']
+    true
+  end
+end
+copy_id = @student.brand_new_copy({:callbacks => [:update_name_when_copy]})
+
+# prefix grade, students, teachers name with 'Copy of ', and reset students score to nil during copy
+[Grade, Teacher, Student].each do |klass|
+  klass.class_eval do
+    def self.update_name_when_copy(hash_origin, hash_copy, full_context)
+      hash_copy['name'] = 'Copy Of ' + hash_origin['name']
+      true
+    end
+  end
+end
+
+Score.class_eval do
+  def self.reset_value_when_copy(hash_origin, hash_copy, full_context)
+    hash_copy['value'] = nil
+    true
+  end
+end
+copy_id = @grade.brand_new_copy({
+  :associations => [{:teachers => [:students]}, {:students => [:scores]}],
+  :callbacks => [
+    :update_name_when_copy,
+    {:teachers => [:update_name_when_copy]},
+    {:students => [:update_name_when_copy, {:scores => [:reset_value_when_copy]}]}
+  ]
+})
+```
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'acts_as_brand_new_copy'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install acts_as_brand_new_copy
+
+## Current Limitation
+- do not support has_many_and_belongs_to_many associations when join table class has a strange table_name(I mean, table_name not in [Class.name.underscore, Class.name.underscore.pluralize])
+
+## Contribute
+
+You're highly welcome to improve this gem.
+
+### Checkout source code to local
+say you git clone the source code to /tmp/acts_as_brand_new_copy
+
+### Install dev bundle
+```bash
+$ cd /tmp/acts_as_brand_new_copy
+$ bundle install
+```
+
+### Do some changes
+```bash
+$ vi lib/acts_as_brand_new_copy.rb
+```
+
+### Run test
+```bash
+$ bundle exec rspec spec
+```

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/acts_as_brand_new_copy.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'acts_as_brand_new_copy/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "acts_as_brand_new_copy"
+  spec.version       = ActsAsBrandNewCopy::VERSION
+  spec.authors       = ["Ben Cao"]
+  spec.email         = ["benb88@gmail.com"]
+  spec.description   = "A ruby gem for active record which simplify the copy of very complex tree data."
+  spec.summary       = "Just give me the object tree specification and callbacks, I will do all the rest for you."
+  spec.homepage      = "https://github.com/bencao/acts_as_brand_new_copy"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake", "~> 10.0.4"
+  spec.add_development_dependency "rspec", "~> 2.13.0"
+  spec.add_development_dependency "mocha", "~> 0.13.3"
+  spec.add_development_dependency "sqlite3", "~> 1.3.7"
+  spec.add_development_dependency "database_cleaner"
+  spec.add_development_dependency "factory_girl"
+  spec.add_development_dependency "factory_girl_rails"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "pry-theme"
+  spec.add_development_dependency "pry-nav"
+  spec.add_dependency "activesupport", "~> 3.2.13"
+  spec.add_dependency "activerecord", "~> 3.2.13"
+end

data/db/database.yml

@@ -0,0 +1,5 @@
+development:
+   adapter: sqlite3
+   database: db/data.sqlite3
+   pool: 5
+   timeout: 5000

data/lib/acts_as_brand_new_copy.rb

@@ -0,0 +1,439 @@
+require "acts_as_brand_new_copy/version"
+
+module ActsAsBrandNewCopy
+  extend ActiveSupport::Concern
+
+  class BrandNewCopyBuilder
+
+    def initialize(hash_origin, hash_copy)
+      @hash_origin  = hash_origin
+      @hash_copy    = hash_copy
+      @save_order   = calculate_save_order
+      @instances    = extract_instances
+      @queue        = prepare_copy_queue
+      @full_context = {
+        :root_hash_origin => @hash_origin,
+        :root_hash_copy   => @hash_copy,
+        :save_order       => @save_order,
+        :save_queue       => @queue,
+        :instances        => @instances
+      }
+    end
+
+    def invoke_callback(callbacks)
+      invoke_callback_recursively([@hash_origin], callbacks)
+    end
+
+    def save
+      @queue.each_pair do |klass_name, hash_copy_array|
+        next if hash_copy_array.blank?
+
+        # belongs_to
+        hash_copy_array.each{ |hash_copy| update_key_on_self_table(klass_name, hash_copy) }
+
+        # AN OPTIMIZED APPROACH IS TO BATCH INSERT THE SAME LEVEL
+        # BUT NOTE CURRENT IMPLEMENTATION IS IS FOR MYSQL ONLY
+        batch_insert_copy(klass_name.constantize, hash_copy_array)
+
+        # has_one, has_many and has_and_belongs_to_many
+        hash_copy_array.each{ |hash_copy| update_key_on_association_tables(klass_name, hash_copy) }
+      end
+    end
+
+    def all_saved_instances
+      @instances.values
+    end
+
+    private
+
+    def invoke_callback_recursively(hash_origin_array, callbacks)
+      raise 'callbacks option must be an array' unless callbacks.is_a?(Array)
+
+      hash_origin_array.each_with_index do |hash_origin, index|
+        raise 'hash_origin must be an hash' unless hash_origin.is_a?(Hash)
+
+        hash_klass = hash_origin['klass'].constantize
+
+        callbacks.each do |callback|
+          if callback.is_a?(Symbol)
+            unless hash_klass.send(callback, hash_origin, find_object_by_old_id(hash_origin['klass'], hash_origin['id_before_copy']), @full_context)
+              raise "run #{callback} callback failed, " +
+                " hash_origin=#{find_object_by_old_id(hash_origin['klass'], hash_origin['id_before_copy'])}"
+            end
+          elsif callback.is_a?(Hash)
+            path, path_callbacks = hash_klass.reflect_on_association(callback.keys.first).class_name, callback.values.first
+            invoke_callback_recursively(hash_partial_by_path(hash_origin, [path]), path_callbacks)
+          else
+            raise 'the callback param value must be a symbol or hash'
+          end
+        end
+      end
+    end
+
+    def hash_partial_by_path(hash, path)
+      path_dup = path.dup
+      hash_partial = hash
+      hash_partial = hash_partial['associations'][path_dup.shift] while path_dup.present?
+      hash_partial
+    end
+
+    def calculate_save_order
+      constraints, klasses = Set.new, Set.new
+      traverse do |current_hash|
+        klasses.add(current_hash['klass']) unless klasses.include?(current_hash['klass'])
+
+        current_hash['dependencies'].each_pair do |aso_name, aso_dependencies|
+          aso_dependencies.each do |aso_dependency|
+            aso_dependency['save_order_constraints'].each do |constraint_string|
+              front, back = constraint_string.split('_')
+              klasses.add(front) unless klasses.include?(front)
+              klasses.add(back) unless klasses.include?(back)
+              # same active record class
+              unless front == back || constraints.include?(constraint_string)
+                constraints.add(constraint_string)
+              end
+            end
+          end
+        end
+      end
+
+      # construct an order which can ensure all constraints are met
+      valid_save_order = klasses.to_a.sort
+      has_modifications = true
+      while has_modifications
+        has_modifications = false
+        constraints.each do |constraint|
+          front, back = constraint.split('_')
+          front_index = valid_save_order.index(front)
+          back_index = valid_save_order.index(back)
+          if front_index > back_index
+            valid_save_order[back_index], valid_save_order[front_index] = front, back
+            has_modifications = true
+          end
+        end
+      end
+      valid_save_order
+    end
+
+    # breadth first
+    def traverse(&block)
+      not_visit = [@hash_copy]
+      while (not_visit.size > 0)
+        current_hash = not_visit.shift
+        yield current_hash
+        current_hash['associations'].each_pair do |aso_name, aso_hash_array|
+          aso_hash_array.each{ |aso_hash| not_visit << aso_hash }
+        end
+      end
+    end
+
+    def extract_instances
+      unique_instances = {}
+      traverse do |current_hash|
+        key = object_key(current_hash['klass'], current_hash['id'])
+        if unique_instances.has_key?(key)
+          unique_instances[key] = merge_associations_dependencies_for_copy(unique_instances[key], current_hash)
+        else
+          unique_instances[key] = current_hash
+        end
+      end
+      unique_instances
+    end
+
+    def merge_associations_dependencies_for_copy(hash, another_hash)
+      dup = hash.reject{ |k, v| ['associations', 'dependencies'].include?(k) }
+
+      dup['associations'] = {}
+      (hash['associations'].keys + another_hash['associations'].keys).each do |aso_name|
+        dup['associations'][aso_name] = (hash['associations'][aso_name] || []) + (another_hash['associations'][aso_name] || [])
+      end
+
+      dup['dependencies'] = {}
+      (hash['dependencies'].keys + another_hash['dependencies'].keys).each do |aso_name|
+        dup['dependencies'][aso_name] = (hash['dependencies'][aso_name] || []) + (another_hash['dependencies'][aso_name] || [])
+      end
+
+      dup
+    end
+
+    def prepare_copy_queue
+      queue = ActiveSupport::OrderedHash.new
+      @save_order.each{ |item| queue[item] = [] }
+      @instances.each_pair{ |key, hash| queue[hash['klass']] << hash }
+      queue
+    end
+
+    def update_key_on_self_table(klass_name, hash_copy)
+      hash_copy['dependencies'].each_pair do |aso_name, aso_dependencies|
+        aso_dependencies.each do |aso_dependency|
+          if aso_dependency['key_position'] == 'self_table'
+            foreign_key = aso_dependency['association_key_on_self_table']
+            update_object_by_old_id(klass_name, hash_copy['id'], {
+              foreign_key => new_id(aso_name, hash_copy[foreign_key])
+            })
+          end
+        end
+      end
+    end
+
+    def update_key_on_association_tables(klass_name, hash_copy)
+      hash_copy['dependencies'].each_pair do |aso_name, aso_dependencies|
+        aso_dependencies.each do |aso_dependency|
+          if aso_dependency['key_position'] == 'association_table'
+            aso_foreign_key = aso_dependency['self_key_on_association_table']
+            hash_copy['associations'][aso_name].each do |instance|
+              update_object_by_old_id(aso_name, instance['id'], {
+                aso_foreign_key => new_id(klass_name, instance[aso_foreign_key])
+              })
+            end
+          elsif aso_dependency['key_position'] == 'join_table'
+            foreign_key_to_self = aso_dependency['self_key_on_join_table']
+            foreign_key_to_association = aso_dependency['association_key_on_join_table']
+            join_table_instances = hash_copy['associations'][aso_dependency['join_table_class']]
+            join_table_instances.each do |instance|
+              update_object_by_old_id(aso_dependency['join_table_class'], instance['id'], {
+                foreign_key_to_self        => new_id(klass_name, instance[foreign_key_to_self]),
+                foreign_key_to_association => new_id(aso_name, instance[foreign_key_to_association])
+              })
+            end
+          end
+        end
+      end
+    end
+
+    def do_insert(klass, columns, hash_copies)
+      connection = klass.connection
+      values_string = hash_copies.map do |hash_copy|
+        quoted_copy_values = columns.map do |column|
+          case column.name
+          when 'updated_at', 'created_at'
+            'NOW()'
+          else
+            connection.quote(hash_copy[column.name], column)
+          end
+        end
+        "(#{quoted_copy_values.join(',')})"
+      end.join(',')
+      result = connection.execute("INSERT INTO #{klass.table_name} (#{columns.map(&:name).join(',')}) VALUES #{values_string}")
+      connection.last_inserted_id(result)
+    end
+
+    def batch_insert_copy_auto_generate_ids(klass, hash_copy_slice)
+      columns = klass.columns.reject {|k, v| 'id' == k.name}
+      last_id = do_insert(klass, columns, hash_copy_slice)
+      first_id = last_id - hash_copy_slice.size + 1
+      hash_copy_slice.each_with_index{ |hash_copy, index| hash_copy['id'] = first_id + index }
+    end
+
+    def batch_insert_copy(klass, hash_copy_array)
+      # in case of array too large
+      hash_copy_array.each_slice(50) do |hash_copy_slice|
+        batch_insert_copy_auto_generate_ids(klass, hash_copy_slice)
+      end
+    end
+
+    def self.object_key(klass, id)
+      absolute_klass_name = klass.start_with?("::") ? "#{klass}" : "::#{klass}"
+      absolute_klass_name.constantize.table_name + "_#{id}"
+    end
+
+    def object_key(klass, id)
+      self.class.object_key(klass, id)
+    end
+
+    def find_object_by_old_id(klass_name, old_id)
+      @instances[object_key(klass_name, old_id)]
+    end
+
+    def new_id(klass_name, old_id)
+      copy_object = find_object_by_old_id(klass_name, old_id)
+      return nil if copy_object.nil?
+      raise 'copy object not saved to db!' if copy_object['id'] == copy_object['id_before_copy']
+      copy_object['id']
+    end
+
+    def update_object_by_old_id(klass_name, old_id, new_attributes)
+      copy_object = find_object_by_old_id(klass_name, old_id)
+      new_attributes.each_pair do |key, value|
+        copy_object[key] = value
+      end
+      if copy_object['id'] != copy_object['id_before_copy']
+        # object already saved, this may happens when the same level copies has dependencies
+        update_inserted_copy(copy_object['klass'].constantize, copy_object['id'], new_attributes)
+      end
+    end
+
+    def update_inserted_copy(klass, id, new_attributes)
+      sub_conditions = []
+      new_attributes.each_pair do |key, value|
+        sub_conditions << "#{key}=#{value}"
+      end
+      klass.connection.execute("UPDATE #{klass.table_name} SET #{sub_conditions.join(',')} WHERE id=#{id}")
+    end
+
+  end
+
+  module ClassMethods
+    def brand_new_copy_object_key(klass, id)
+      BrandNewCopyBuilder.object_key(klass, id)
+    end
+
+    def brand_new_copy_guess_join_table_class(join_table_name)
+      final_name = [join_table_name.singularize, join_table_name.pluralize].detect do |possible_name|
+        Object.const_defined?(possible_name.camelize)
+      end
+      if final_name
+        final_name.camelize
+      else
+        raise "Do not support has_and_belongs_to_many associations" +
+          "that can not guess join table class from join table name"
+      end
+    end
+  end
+
+  def quoted_attributes_for_copy
+    quoted_attributes = {}
+    attributes.each_pair do |key, value|
+      case value.class.to_s
+      when "Date", "Time", "ActiveSupport::TimeWithZone"
+        quoted_attributes[key] = connection.quoted_date(value)
+      when "BigDecimal"
+        quoted_attributes[key] = value.to_s("F")
+      else
+        quoted_attributes[key] = value
+      end
+    end
+    # in case the table has no id
+    unless quoted_attributes.has_key?('id')
+      quoted_attributes['id'] = quoted_attributes.values.join('_')
+    end
+    quoted_attributes['id_before_copy'] = quoted_attributes['id']
+    quoted_attributes['klass'] = self.class.to_s
+    quoted_attributes
+  end
+
+  # sample associations = [:billing_term_condition, {:line_items => [:targeting_criteria]}, :resource_user_assignments]
+  def serialize_hash_for_copy(associations=nil)
+    associations = [] if associations.nil?
+    raise "associations param (#{associations}) must be inside an array" unless associations.is_a?(Array)
+
+    result = quoted_attributes_for_copy.merge({
+      'associations'   => {},
+      'dependencies'   => {}
+    })
+
+    associations.uniq.each do |association|
+      if association.is_a?(Symbol)
+        aso_name_underscore, aso_instances, aso_option = association.to_s, self.send(association), nil
+      elsif association.is_a?(Hash)
+        aso_name_underscore, aso_instances, aso_option = association.keys.first.to_s, self.send(association.keys.first), association.values.first
+      else
+        raise 'association param value must be a symbol or hash'
+      end
+
+      reflection = self.class.reflect_on_association(aso_name_underscore.to_sym)
+      unless result['dependencies'].has_key?(reflection.class_name)
+        result['dependencies'][reflection.class_name] = []
+      end
+      result['dependencies'][reflection.class_name] << resolve_copy_dependencies(reflection)
+
+      unless result['associations'].has_key?(reflection.class_name)
+        result['associations'][reflection.class_name] = if aso_instances.is_a?(Array)
+          aso_instances.map{ |ass| ass.serialize_hash_for_copy(aso_option) }
+        else
+          aso_instances.present? ? [aso_instances.serialize_hash_for_copy(aso_option)] : []
+        end
+      end
+
+      # has_and_belongs_to_many and has_one(through), has_many(through) may introduce an implicit association
+      implicit_association_class, implicit_association_hash = implicit_join_table_association(reflection)
+      if implicit_association_class.present? && (not result['associations'].has_key?(implicit_association_class))
+        result['associations'][implicit_association_class] = implicit_association_hash
+      end
+    end
+    result
+  end
+
+  def resolve_copy_dependencies(reflection)
+    self_class = reflection.active_record.to_s
+    association_class = reflection.class_name
+    if (reflection.through_reflection.present?)
+      join_table_class = reflection.through_reflection.class_name
+      # has_one through OR has_many through
+      {
+        'key_position'                  => 'join_table',
+        'save_order_constraints'        => [
+          "#{self_class}_#{join_table_class}",
+          "#{association_class}_#{join_table_class}",
+          "#{association_class}_#{self_class}"
+        ],
+        'join_table_class'              => join_table_class,
+        'self_key_on_join_table'        => reflection.through_reflection.foreign_key,
+        'association_key_on_join_table' => reflection.source_reflection.foreign_key
+      }
+    else
+      case (reflection.macro)
+      when :has_and_belongs_to_many
+        join_table_class = self.class.brand_new_copy_guess_join_table_class(reflection.options[:join_table])
+        {
+          'key_position'                  => 'join_table',
+          'save_order_constraints'        => [
+            "#{self_class}_#{join_table_class}",
+            "#{association_class}_#{join_table_class}",
+            "#{association_class}_#{self_class}"
+          ],
+          'join_table_class'              => join_table_class,
+          'self_key_on_join_table'        => reflection.foreign_key,
+          'association_key_on_join_table' => reflection.association_foreign_key
+        }
+      when :has_one, :has_many
+        {
+          'key_position'                  => 'association_table',
+          'save_order_constraints'        => ["#{self_class}_#{association_class}"],
+          'self_key_on_association_table' => reflection.foreign_key
+        }
+      when :belongs_to
+        {
+          'key_position'                  => 'self_table',
+          'save_order_constraints'        => ["#{association_class}_#{self_class}"],
+          'association_key_on_self_table' => reflection.foreign_key
+        }
+      else
+        raise 'should not have reflection macro other than belongs_to has_and_belongs_to_many has_one has_many'
+      end
+    end
+  end
+
+  def implicit_join_table_association(reflection)
+    # belongs_to, has_one(without through), has_many(without through) have no implicit join table
+    return nil, nil if (reflection.through_reflection.blank? && reflection.macro != :has_and_belongs_to_many)
+
+    if reflection.macro == :has_and_belongs_to_many
+      join_table_class = self.class.brand_new_copy_guess_join_table_class(reflection.options[:join_table])
+      self_key_on_join_table = reflection.foreign_key
+    else
+      join_table_class = reflection.through_reflection.class_name
+      self_key_on_join_table = reflection.through_reflection.foreign_key
+    end
+    join_table_instances = join_table_class.constantize.where("#{self_key_on_join_table} = #{self.id}").to_a
+
+    return join_table_class, join_table_instances.map{ |instance| instance.serialize_hash_for_copy(nil) }
+  end
+
+  def brand_new_copy(options={})
+    final_options = {:callbacks => [], :associations => nil}.merge(options)
+
+    eager_loaded_self = self.class.includes(final_options[:associations]).find(id)
+
+    hash_origin = eager_loaded_self.serialize_hash_for_copy(final_options[:associations])
+    hash_copy   = JSON.parse(hash_origin.to_json) # a way to do deep clone
+
+    builder = BrandNewCopyBuilder.new(hash_origin, hash_copy)
+    builder.invoke_callback(final_options[:callbacks])
+    builder.save
+
+    return hash_copy['id']
+  end
+end
+
+ActiveRecord::Base.send(:include, ActsAsBrandNewCopy)

data/lib/acts_as_brand_new_copy/version.rb

@@ -0,0 +1,3 @@
+module ActsAsBrandNewCopy
+  VERSION = "1.0.0"
+end

data/spec/acts_as_brand_new_copy_spec.rb

@@ -0,0 +1,252 @@
+require 'spec_helper'
+require 'acts_as_brand_new_copy'
+
+class Schema < ActiveRecord::Migration
+  def change
+    create_table :grades do |t|
+      t.string :name
+    end
+
+    create_table :teachers do |t|
+      t.string :name
+    end
+
+    create_table :students do |t|
+      t.string :name
+    end
+
+    create_table :scores do |t|
+      t.string :value
+      t.references :student
+    end
+
+    create_table :grade_teacher_assignments, :id => false do |t|
+      t.references :grade
+      t.references :teacher
+    end
+
+    create_table :grade_student_assignments, :id => false do |t|
+      t.references :grade
+      t.references :student
+    end
+
+    create_table :student_teacher_assignments do |t|
+      t.references :teacher
+      t.references :student
+    end
+  end
+
+end
+
+Schema.new.change
+
+class StudentTeacherAssignment < ActiveRecord::Base
+  belongs_to :teacher
+  belongs_to :student
+end
+
+class GradeTeacherAssignment < ActiveRecord::Base
+  belongs_to :grade
+  belongs_to :teacher
+end
+
+class GradeStudentAssignment < ActiveRecord::Base
+  belongs_to :grade
+  belongs_to :student
+end
+
+class Grade < ActiveRecord::Base
+  has_and_belongs_to_many :teachers, :join_table => ::GradeTeacherAssignment.table_name
+  has_and_belongs_to_many :students, :join_table => ::GradeStudentAssignment.table_name
+end
+
+class Teacher < ActiveRecord::Base
+  has_many :student_teacher_assignments
+  has_many :students,
+    :through => :student_teacher_assignments,
+    :source  => :student
+end
+
+class Student < ActiveRecord::Base
+  has_many :student_teacher_assignments
+  has_many :teachers,
+    :through => :student_teacher_assignments,
+    :source  => :teacher
+  has_many :scores
+end
+
+class Score < ActiveRecord::Base
+  belongs_to :student
+end
+
+
+FactoryGirl.define do
+  factory :grade do
+    sequence(:name) {|n| "Grade #{n}"}
+  end
+
+  factory :teacher do
+    sequence(:name) {|n| "Teacher #{n}"}
+  end
+
+  factory :student do
+    sequence(:name) {|n| "Student #{n}"}
+
+    trait :with_scores do
+      after(:create) do |student, evaluator|
+        FactoryGirl.create(:score, {:student => student, :value => "70"})
+        FactoryGirl.create(:score, {:student => student, :value => "80"})
+      end
+    end
+  end
+
+  factory :score do
+  end
+end
+
+describe ActsAsBrandNewCopy do
+  context "copy associations" do
+    it "should copy self" do
+      @student = create(:student)
+      copy_id = @student.brand_new_copy
+      copied_student = Student.find copy_id
+      copied_student.name.should == @student.name
+      copied_student.id.should_not == @student.id
+    end
+
+    it "should copy belongs_to associations" do
+      # NOTE although brand new copy support belongs_to association copy
+      # it's not common in real world that we need to copy belongs_to association
+      # You should avoid doing that or you should check your design
+      @student = create(:student, :with_scores)
+      @score1 = @student.scores.first
+
+      copy_id = @score1.brand_new_copy({:associations => [:student]})
+
+      copied_score = Score.find(copy_id)
+
+      copied_score.student.name.should == @student.name
+      copied_score.student.id.should_not == @student.id
+    end
+
+    it "should copy has_many associations" do
+      @student = create(:student, :with_scores)
+      @score1, @score2 = @student.scores
+
+      copy_id = @student.brand_new_copy({:associations => [:scores]})
+
+      copied_student = Student.find copy_id
+      copied_student.scores.size.should == @student.scores.size
+      copied_student.scores.map(&:value).sort.should == @student.scores.map(&:value).sort
+      (copied_student.scores.map(&:id) - @student.scores.map(&:id)).size.should == 2
+    end
+
+    it "should copy has_many through associations" do
+      @teacher = create(:teacher)
+      @student1, @student2 = create_list(:student, 2)
+      @teacher.students << @student1
+      @teacher.students << @student2
+
+      copy_id = @teacher.brand_new_copy({:associations => [:students]})
+      copied_teacher = Teacher.find copy_id
+      copied_teacher.students.size.should == @teacher.students.size
+      copied_teacher.students.map(&:name).sort.should == @teacher.students.map(&:name).sort
+      (copied_teacher.students.map(&:id) - @teacher.students.map(&:id)).size.should == 2
+    end
+
+    it "should copy has_and_belongs_to_many associations" do
+      @grade = create(:grade)
+      @student1, @student2 = create_list(:student, 2)
+      @grade.students << @student1
+      @grade.students << @student2
+
+      copy_id = @grade.brand_new_copy({:associations => [:students]})
+      copied_grade = Grade.find copy_id
+      copied_grade.students.size.should == @grade.students.size
+      copied_grade.students.map(&:name).sort.should == @grade.students.map(&:name).sort
+      (copied_grade.students.map(&:id) - @grade.students.map(&:id)).size.should == 2
+    end
+
+    it "should not copy a same association instance twice" do
+      @grade = create(:grade)
+      @teacher = create(:teacher)
+      @grade.teachers << @teacher
+      @student1, @student2 = create_list(:student, 2)
+      @grade.students << @student1
+      @grade.students << @student2
+      @teacher.students << @student1
+      @teacher.students << @student2
+
+      copy_id = @grade.brand_new_copy({:associations => [{:teachers => [:students]}, :students]})
+      copied_grade = Grade.find copy_id
+      copied_grade.students.size.should == @grade.students.size
+      (copied_grade.students.map(&:id) - @grade.students.map(&:id)).size.should == 2
+      copied_grade.teachers.size.should == @grade.teachers.size
+      copied_grade.students.map(&:name).sort.should == @grade.students.map(&:name).sort
+      Student.where(:name => @student1.name).size.should == 2
+      Student.where(:name => @student2.name).size.should == 2
+      copied_grade.teachers.first.students.size.should == @teacher.students.size
+      copied_grade.teachers.first.students.map(&:name).sort.should == @teacher.students.map(&:name).sort
+    end
+
+  end
+
+  context "callbacks" do
+    [Grade, Teacher, Student].each do |klass|
+      klass.class_eval do
+        def self.update_name_when_copy(hash_origin, hash_copy, full_context)
+          hash_copy['name'] = copy_of_name(hash_origin['name'])
+          true
+        end
+
+        def self.copy_of_name(name)
+          'Copy of ' + name
+        end
+      end
+    end
+
+    Score.class_eval do
+      def self.reset_value_when_copy(hash_origin, hash_copy, full_context)
+        hash_copy['value'] = nil
+        true
+      end
+    end
+
+    it "should invoke callbacks on self" do
+      @student = create(:student)
+      copy_id = @student.brand_new_copy({:callbacks => [:update_name_when_copy]})
+      copied_student = Student.find copy_id
+      copied_student.name.should == Student.copy_of_name(@student.name)
+    end
+
+    it "should invoke callbacks on associations" do
+      @grade = create(:grade)
+      @teacher = create(:teacher)
+      @grade.teachers << @teacher
+      @student1, @student2 = create_list(:student, 2, :with_scores)
+      @grade.students << @student1
+      @grade.students << @student2
+      @teacher.students << @student1
+      @teacher.students << @student2
+
+      copy_id = @grade.brand_new_copy({
+        :associations => [{:teachers => [:students]}, {:students => [:scores]}],
+        :callbacks => [
+          :update_name_when_copy,
+          {:teachers => [:update_name_when_copy]},
+          {:students => [:update_name_when_copy, {:scores => [:reset_value_when_copy]}]}
+        ]
+      })
+      copied_grade = Grade.find copy_id
+      copied_grade.name.should == Grade.copy_of_name(@grade.name)
+      copied_grade.teachers.first.name.should == Teacher.copy_of_name(@teacher.name)
+      copied_grade.students.map(&:name).sort.should == [
+        Student.copy_of_name(@student1.name),
+        Student.copy_of_name(@student2.name)
+      ].sort
+      copied_grade.students.map(&:scores).flatten.map(&:value).compact.should be_blank
+    end
+
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,33 @@
+require 'active_support'
+require 'active_record'
+require 'sqlite3'
+require 'pry'
+require 'database_cleaner'
+require 'factory_girl'
+
+db_config = YAML::load(IO.read('db/database.yml'))
+db_file = db_config['development']['database']
+File.delete(db_file) if File.exists?(db_file)
+ActiveRecord::Base.configurations = db_config
+ActiveRecord::Base.establish_connection('development')
+
+RSpec.configure do |config|
+  # == Mock Framework
+  # If you prefer to use mocha, flexmock or RR, uncomment the appropriate line:
+  config.mock_with :mocha
+
+  config.before(:suite) do
+    DatabaseCleaner.strategy = :transaction
+    DatabaseCleaner.clean_with(:truncation)
+  end
+
+  config.before(:each) do
+    DatabaseCleaner.start
+  end
+
+  config.after(:each) do
+    DatabaseCleaner.clean
+  end
+
+  config.include FactoryGirl::Syntax::Methods
+end

metadata

@@ -0,0 +1,270 @@
+--- !ruby/object:Gem::Specification
+name: acts_as_brand_new_copy
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+  prerelease: 
+platform: ruby
+authors:
+- Ben Cao
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-11-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.4
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 10.0.4
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 2.13.0
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.3
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.13.3
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.3.7
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: factory_girl_rails
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-theme
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry-nav
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+- !ruby/object:Gem::Dependency
+  name: activerecord
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 3.2.13
+description: A ruby gem for active record which simplify the copy of very complex
+  tree data.
+email:
+- benb88@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- acts_as_brand_new_copy.gemspec
+- db/database.yml
+- lib/acts_as_brand_new_copy.rb
+- lib/acts_as_brand_new_copy/version.rb
+- spec/acts_as_brand_new_copy_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/bencao/acts_as_brand_new_copy
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.25
+signing_key: 
+specification_version: 3
+summary: Just give me the object tree specification and callbacks, I will do all the
+  rest for you.
+test_files:
+- spec/acts_as_brand_new_copy_spec.rb
+- spec/spec_helper.rb