sequel_deep_dup 0.1.1 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dde7ced04065758f9cc497072032be96caf0795d
-  data.tar.gz: 5aa9acc6054864fdd7fa8360217edcafa36fb2eb
+  metadata.gz: 490afcfe5a51e4e24da754246b8a88d4f76d6ac9
+  data.tar.gz: 8473904ed8790f08ab4808abb55843ae329851ba
 SHA512:
-  metadata.gz: e7531307317303235bcd0596701770aad8b126b04c9cc1da3d42663dcb15dc59acccb357a6cd9caf92b95971e8d66cb5547b68a06abf538bc70910a610216b75
-  data.tar.gz: a7868f64e6cec794d6d4867d3794d954920e16787da4a60b74932b31433620914b8459e7c543c3c0e9273cf3d8a096a22949865e489f20af29cab0587eaf81b6
+  metadata.gz: 57d4409e59d8a47cc099bc24db359628b3f9962b15985dbc201fb61becf9845a3fd3add1c34a810f0106ab05ca79ff6172aedfcf54fccb73d766f469a50423f1
+  data.tar.gz: 3a50f39744efb83cd67c43b3e4d053ddce87356c11d4d9e8fa394bc33c7e75597d6110bf77a01be7e400f368c345eacd5e766d8df73538f9833b0f21cf422155

data/Gemfile

@@ -6,3 +6,4 @@ gemspec
 gem 'rspec'
 gem 'sqlite3'
 gem 'sequel'
+gem 'factory_girl'

data/lib/sequel_deep_dup/version.rb

@@ -1,7 +1,7 @@
 module Sequel
   module Plugins
     module DeepDup
-      VERSION = "0.1.1"
+      VERSION = "0.2.1"
     end
   end
 end

data/lib/sequel_deep_dup.rb

@@ -5,24 +5,18 @@ module Sequel
   module Plugins
     module DeepDup
       class DeepDupper
-        attr_reader :instance, :omit_records
+        attr_reader :instance, :omit_records, :associations
 
-        def initialize instance, omit = []
+        def initialize instance, opts = {}
           @instance     = instance
-          @omit_records = omit
-        end
-
-        def dup_associations instance, copy, associations
-          associations.each do |name|
-            next unless refl = instance.class.association_reflection(name)
-            [*instance.send(name)].compact.each { |rec| instantiate_associated(copy, refl, rec) }
-          end
+          @associations = opts[:associations]
+          @omit_records = opts[:omit_records] || []
         end
 
         def dup
           copy = shallow_dup.extend(InstanceHooks::InstanceMethods)
           omit_records << instance
-          dup_associations(instance, copy, instance.class.associations)
+          dup_associations(instance, copy, associations)
           copy
         end
 
@@ -33,12 +27,38 @@ module Sequel
           klass.new attributes
         end
 
+        def dup_associations instance, copy, includes = nil
+          includes &&= includes.map { |item| [*item].flatten }
+          associations = instance.class.associations
+
+          ([*includes].map{ |i| i.first } - associations).each do |assoc|
+            raise(Error, "no association named #{assoc} for #{instance}")
+          end
+
+          associations.each do |name|
+            next unless refl = instance.class.association_reflection(name)
+            [*instance.send(name)].compact.each do |rec|
+              if includes
+                next unless graph = includes.assoc(refl[:name])
+                instantiate_associated(copy, refl, rec, graph[1..-1])
+              else
+                next copy.values.delete(refl[:key]) if refl[:type] == :many_to_one
+                instantiate_associated(copy, refl, rec, nil)
+              end
+            end
+          end
+        end
+
         private
-        def instantiate_associated copy, reflection, record
+        def instantiate_associated copy, reflection, record, associations
           return if omit_records.detect { |to_omit| record.pk == to_omit.pk && record.class == to_omit.class }
 
           unless reflection[:type] == :many_to_many
-            record = DeepDupper.new(record, omit_records).dup
+            record = DeepDupper.new(
+              record,
+              :omit_records => omit_records,
+              :associations => associations
+            ).dup
           end
 
           if reflection.returns_array?
@@ -46,12 +66,11 @@ module Sequel
             copy.after_save_hook{ copy.send(reflection.add_method, record) }
           else
             copy.associations[reflection[:name]] = record
-
             copy.instance_variable_set :@set_associated_object_if_same, true
 
-            if reflection[:type] == :many_to_one 
+            if reflection[:type] == :many_to_one
               copy.before_save_hook {
-                copy.send reflection.setter_method, record.save(:validate=>false)
+                copy.send reflection.setter_method, record.save
               }
             else
               copy.after_save_hook{
@@ -63,8 +82,9 @@ module Sequel
       end
 
       module InstanceMethods
-        def deep_dup
-          DeepDupper.new(self).dup
+        def deep_dup *associations
+          associations = nil if associations.empty?
+          DeepDupper.new(self, :associations => associations).dup
         end
       end
     end

data/spec/deep_dup_spec.rb

@@ -1,127 +1,165 @@
 require 'spec_helper'
 
 describe Sequel::Plugins::DeepDup do
-  let(:program)         { Program.create name: 'CS' }
+  let(:program)         { create :program, :name =>'CS' }
   let(:program_copy)    { program.deep_dup }
-  let(:course)          { Course.create name: 'Ruby', program: program }
+  let(:course)          { create :course, :name => 'Ruby', :program => program }
   let(:course_copy)     { course.deep_dup }
-  let(:student)         { Student.create name: 'Macario' }
+  let(:student)         { create :student, :name => 'Macario' }
   let(:student_copy)    { student.deep_dup }
-  let(:enrollment)      { Enrollment.create(student_id: student.id, course_id: course.id) }
+  let(:enrollment)      { create :enrollment, :student_id => student.id, :course_id => course.id }
   let(:enrollment_copy) { enrollment.deep_dup }
 
-  describe 'duplicating plain record' do
-
+  context 'no explicit assoc graph is passed' do
     before do
-      Program.plugin :deep_dup
-      Enrollment.plugin :deep_dup
+      enable_deep_dup_for Program, Course, Enrollment, Student, Profile, Account
     end
 
-    it { program_copy.name.should == 'CS' }
-    it { program_copy.pk.should be_nil } 
-    it { program_copy.should be_new } 
-    it { enrollment_copy.pk.should == [nil, nil] } 
-    it { enrollment_copy.should be_new }
-  end
+    describe 'duplication plain record' do
+      context 'with regular pk' do
+        it { program_copy.name.should == 'CS' }
+        it { program_copy.pk.should be_nil } 
+      end
 
-  describe 'duplicating record with a one to many association' do
-    before do
-      Program.plugin :deep_dup
-      3.times { |num| program.add_course name: "Course #{num}" }
+      context 'with composite pks' do
+        it { program_copy.should be_new } 
+        it { enrollment_copy.pk.should == [nil, nil] } 
+        it { enrollment_copy.should be_new }
+      end
     end
 
-    it { program_copy.should have(3).courses }
-    it { program_copy.courses.map(&:pk).should be_none }
-    it { expect { program_copy.save }.to change{ Course.count }.to(6) }
-  end
+    describe 'duplicating one to many children' do
+      before do
+        3.times { |num| program.add_course :name => "Course #{num}" }
+      end
 
-  describe 'duplicating record with a many to many association' do
-    before do
-      Course.plugin :deep_dup
-      3.times { |num| course.add_category name: "Category #{num}" }
+      context 'with no nesting' do
+        it { program_copy.should have(3).courses }
+        it { program_copy.courses.map(&:pk).should be_none }
+        it { expect { program_copy.save }.to change{ Course.count }.to(6) }
+      end
+
+      context 'with nesting' do
+        before do
+          program.courses.each do |course|
+            3.times { |num| course.add_assignment :name => "Assignment #{num}" }
+          end
+        end
+
+        it { program_copy.should have(3).courses }
+        it { program_copy.courses.first.should have(3).assignments }
+        it { expect { program_copy.save }.to change{ Course.count }.to(6) }
+        it { expect { program_copy.save }.to change{ Assignment.count }.to(18) }
+      end
     end
 
-    it { course_copy.should have(3).categories }
-    it { course_copy.categories.should == course.categories }
-    it { expect { course_copy.save }.not_to change{ Category.count } }
-  end
+    describe 'reasociating to many to many' do
+      context 'when has many to many children' do
+        before do
+          3.times { |num| course.add_category :name => "Category #{num}" }
+        end
 
-  describe 'duplicating record with nested many to one' do
-    before do
-      Program.plugin :deep_dup
-      3.times { |num| program.add_course name: "Course #{num}" }
+        it { course_copy.should have(3).categories }
+        it { course_copy.categories.should == course.categories }
+        it { expect { course_copy.save }.not_to change{ Category.count } }
+      end
 
-      program.courses.each do |course|
-        3.times { |num| course.add_assignment name: "Assignment #{num}" }
+      context 'when child has many to many children' do
+        before do
+          3.times { |num| program.add_course :name => "Course #{num}" }
+          program.courses.each do |course|
+            3.times { |num| course.add_category :name => "Category #{num}" }
+          end
+        end
+
+        it { program_copy.should have(3).courses }
+        it { program_copy.courses.first.should have(3).categories }
+        it { program_copy.courses.last.should have(3).categories }
+        it { expect { program_copy.save }.not_to change{ Category.count } }
       end
     end
 
-    it { program_copy.should have(3).courses }
-    it { program_copy.courses.first.should have(3).assignments }
-    it { expect { program_copy.save }.to change{ Course.count }.to(6) }
-    it { expect { program_copy.save }.to change{ Assignment.count }.to(18) }
-  end
+    describe 'duplicating record with one to one' do
+      context 'when regular fk' do
+        before { student.account = Account.new(:email => 'mail@makarius.me') }
+        it { student_copy.account.pk.should be_nil }
+        it { student_copy.account.email.should == 'mail@makarius.me' }
+        it { expect { student_copy.save }.to change { Account.count }.to(2) }
+      end
 
-  describe 'duplicating record with a many to many association after a many to one' do
-    before do
-      Program.plugin :deep_dup
-      3.times { |num| program.add_course name: "Course #{num}" }
-      program.courses.each do |course|
-        3.times { |num| course.add_category name: "Category #{num}" }
+      context 'when foreign key is also pk' do
+        before do
+          student.profile = create(:profile, :bio => 'likes sequel, rides bycicle', :student => student)
+        end
+        it { student_copy.profile.pk.should be_nil }
+        it { student_copy.profile.bio.should == 'likes sequel, rides bycicle' }
+        it { expect { student_copy.save }.to change { Profile.count }.to(2) }
       end
     end
-    
-    it { program_copy.should have(3).courses }
-    it { program_copy.courses.first.should have(3).categories }
-    it { program_copy.courses.last.should have(3).categories }
-    it { expect { program_copy.save }.not_to change{ Category.count } }
-  end
 
-  describe 'duplicating record with one to one' do
-    before do
-      Student.plugin :deep_dup
-      student.account = Account.new(email: 'mail@makarius.me')
-    end
+    describe 'omits many to one association' do
+      context 'when regular fk' do
+        let(:account)      { create(:account, :email => 'mail@makarius.me', :student => student) }
+        let(:account_copy) { account.deep_dup }
+        it { account_copy.student_id.should be_nil }
+        it { account_copy.student.should be_nil }
+        it { account_copy.email.should == 'mail@makarius.me' }
+      end
 
-    it { student_copy.account.pk.should be_nil }
-    it { student_copy.account.email.should == 'mail@makarius.me' }
-    it { expect { student_copy.save }.to change { Account.count }.to(2) }
+      context 'when foreign key is also pk' do
+        let(:profile)      { create(:profile, :bio => 'likes sequel, rides bycicle', :student => student) }
+        let(:profile_copy) { profile.deep_dup }
+        it { profile_copy.student.should be_nil }
+        it { profile_copy.student_id.should be_nil }
+        it { profile_copy.bio.should == 'likes sequel, rides bycicle' }
+      end
+    end
   end
 
-  describe 'duplicating record with many to one association' do
+  describe 'restrictions' do
     before do
-      Account.plugin :deep_dup
+      Program.plugin :deep_dup
     end
 
-    let(:account)      { Account.create(email: 'mail@makarius.me', student: student) }
-    let(:account_copy) { account.deep_dup }
-
-    it { account_copy.student.pk.should be_nil }
-    it { account_copy.student.name.should == 'Macario' }
-    it { expect { account_copy.save }.to change { Student.count }.to(2) }
-  end
+    let!(:program) { create :program, :with_graph }
 
-  describe 'duplicating record with one to one when foreign key is pk' do
-    before do
-      Student.plugin :deep_dup
-      student.profile = Profile.create(bio: 'likes sequel, rides bycicle', student: student)
+    describe 'validate graph' do
+      it { Course.count.should be 3 }
+      it { Assignment.count.should be 9 }
+      it { Enrollment.count.should be 9 }
+      it { Student.count.should be 9 }
+      it { Account.count.should be 9 }
+      it { Profile.count.should be 9 }
+      it { Category.count.should be 9 }
     end
 
-    it { student_copy.profile.pk.should be_nil }
-    it { student_copy.profile.bio.should == 'likes sequel, rides bycicle' }
-    it { expect { student_copy.save }.to change { Profile.count }.to(2) }
-  end
-
-  describe 'duplicating record with many to one association when foreign key is pk' do
-    before do
-      Profile.plugin :deep_dup
+    describe 'restricts to children' do
+      let(:program_copy) { program.deep_dup :courses }
+      it { expect { program_copy.save }.to change{ Course.count }.by(3) }
+      it { expect { program_copy.save }.not_to change{ Enrollment.count } }
+    end 
+
+    describe 'restricts to children of children' do
+      let(:program_copy) { program.deep_dup :courses => :assignments }
+      it { expect { program_copy.save }.to change{ Course.count }.by(3) }
+      it { expect { program_copy.save }.to change{ Assignment.count }.by(9) }
+      it { expect { program_copy.save }.not_to change{ Enrollment.count } }
     end
 
-    let(:profile)      { Profile.create(bio: 'likes sequel, rides bycicle', student: student) }
-    let(:profile_copy) { profile.deep_dup }
+    describe 'restricts to graph' do
+      let(:program_copy) { program.deep_dup :courses => [:assignments, :categories, {:enrollments => {:student => [:profile, :account]}}] }
+      it { expect { program_copy.save }.to change { Course.count }.by(3) }
+      it { expect { program_copy.save }.to change { Assignment.count }.by(9) }
+      it { expect { program_copy.save }.to change { Enrollment.count }.by(9) }
+      it { expect { program_copy.save }.to change { Student.count }.by(9) }
+      it { expect { program_copy.save }.to change { Account.count }.by(9) }
+      it { expect { program_copy.save }.to change { Profile.count }.by(9) }
+      it { expect { program_copy.save }.to change { DB[:course_categories].count }.by(9) }
+      it { expect { program_copy.save }.not_to change { Category.count } }
+    end
 
-    it { profile_copy.student.pk.should be_nil }
-    it { profile_copy.student.name.should == 'Macario' }
-    it { expect { profile_copy.save }.to change { Student.count }.to(2) }
+    it 'raises exception when association present in graph is not defined in model' do
+      expect { program.deep_dup :potatoes }.to raise_error(Sequel::Error) 
+    end
   end
 end

data/spec/spec_helper.rb

@@ -9,8 +9,16 @@ load 'support/migrations.rb'
 DB = Sequel.sqlite
 Sequel::Migration.descendants.each { |m| m.apply(DB, :up) }
 
+module Helpers
+  def enable_deep_dup_for *models
+    models.each { |model| model.plugin :deep_dup }
+  end
+end
 
 RSpec.configure do |config|
+  config.include FactoryGirl::Syntax::Methods
+  config.include Helpers
+
   config.around :each do |example|
     load 'support/models.rb'
 
@@ -24,3 +32,6 @@ RSpec.configure do |config|
     end
   end
 end
+
+FactoryGirl.definition_file_paths = %w(spec/support)
+FactoryGirl.reload

data/spec/support/factories.rb

@@ -0,0 +1,59 @@
+FactoryGirl.define do
+  factory :program do
+    to_create { |instance| instance.save }
+    sequence(:name) { |num| "Program #{num}" }
+    
+    trait :with_graph do
+      courses_attributes { attributes_for_list(:course, 3, :with_graph) }
+    end
+  end
+
+  factory :course do
+    to_create { |instance| instance.save }
+    sequence(:name) { |num| "Course #{num}" }
+
+    trait :with_graph do
+      assignments_attributes { attributes_for_list(:assignment, 3) }
+      enrollments_attributes { attributes_for_list(:enrollment, 3, :with_graph) }
+      categories_attributes  { attributes_for_list(:category, 3) }
+    end
+  end
+
+  factory :assignment do
+    to_create { |instance| instance.save }
+    sequence(:name) { |num| "Assignment #{num}" }
+  end
+
+  factory :student do
+    to_create { |instance| instance.save }
+    sequence(:name) { |num| "Student #{num}" }
+
+    trait :with_graph do
+      profile_attributes { attributes_for(:profile) }
+      account_attributes { attributes_for(:account) }
+    end
+  end
+
+  factory :account do
+    to_create { |instance| instance.save }
+    sequence(:email) { |num| "student-#{num}@example.com" }
+  end
+
+  factory :profile do
+    to_create { |instance| instance.save }
+    sequence(:bio) { |num| "Student #{num}: lorem ipsum..." }
+  end
+
+  factory :enrollment do
+    to_create { |instance| instance.save }
+
+    trait :with_graph do
+      student_attributes { attributes_for(:student, :with_graph) }
+    end
+  end
+
+  factory :category do
+    to_create { |instance| instance.save }
+    sequence(:name) { |num| "Category #{num}" }
+  end
+end

data/spec/support/migrations.rb

@@ -7,7 +7,7 @@ Sequel.migration do
 
     create_table :courses do
       primary_key :id
-      foreign_key :program_id, :programs, :on_delete => :restrict, :on_update => :restrict, :null => false
+      foreign_key :program_id, :programs, :on_delete => :restrict, :on_update => :restrict
       String :name, null: false
       Date :starts
       Date :ends

data/spec/support/models.rb

@@ -1,21 +1,44 @@
+Sequel::Model.plugin :nested_attributes
+Sequel::Model.plugin :auto_validations
+
 class Program < Sequel::Model
   one_to_many :courses
+
+  nested_attributes :courses
 end
 
 class Course < Sequel::Model
   many_to_one  :program
   one_to_many  :assignments
+  one_to_many  :enrollments
+
   many_to_many :categories, join_table: :course_categories
+  
+  nested_attributes :assignments
+  nested_attributes :enrollments
+  nested_attributes :categories
 end
 
 class Assignment < Sequel::Model
   many_to_one :course
 end
 
+class Enrollment < Sequel::Model
+  unrestrict_primary_key
+  set_primary_key [:student_id, :course_id]
+  many_to_one :student
+  many_to_one :course
+
+  nested_attributes :student
+end
+
 class Student < Sequel::Model
   one_to_many :enrollments
   one_to_one  :account
   one_to_one  :profile
+
+  nested_attributes :account
+  nested_attributes :profile
 end
 
 class Account < Sequel::Model
@@ -27,13 +50,6 @@ class Profile < Sequel::Model
   many_to_one :student
 end
 
-class Enrollment < Sequel::Model
-  unrestrict_primary_key
-  set_primary_key [:student_id, :course_id]
-  many_to_one :student
-  many_to_one :course
-end
-
 class Category < Sequel::Model
   many_to_many :courses, join_table: :course_categories
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel_deep_dup
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.1
 platform: ruby
 authors:
 - macario
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-31 00:00:00.000000000 Z
+date: 2014-04-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -57,6 +57,7 @@ files:
 - sequel_deep_dup.gemspec
 - spec/deep_dup_spec.rb
 - spec/spec_helper.rb
+- spec/support/factories.rb
 - spec/support/migrations.rb
 - spec/support/models.rb
 homepage: ''
@@ -87,6 +88,7 @@ summary: Makes deep copies of existing sequel models into a new record, along wi
 test_files:
 - spec/deep_dup_spec.rb
 - spec/spec_helper.rb
+- spec/support/factories.rb
 - spec/support/migrations.rb
 - spec/support/models.rb
 has_rdoc: