sequel_deep_dup 0.2.1 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 490afcfe5a51e4e24da754246b8a88d4f76d6ac9
-  data.tar.gz: 8473904ed8790f08ab4808abb55843ae329851ba
+  metadata.gz: f6f02dab9f3b6c333a4de5c5fd5a5079a8cbd0c2
+  data.tar.gz: 590e586fd31aa82f8066adee879bfe1932f13436
 SHA512:
-  metadata.gz: 57d4409e59d8a47cc099bc24db359628b3f9962b15985dbc201fb61becf9845a3fd3add1c34a810f0106ab05ca79ff6172aedfcf54fccb73d766f469a50423f1
-  data.tar.gz: 3a50f39744efb83cd67c43b3e4d053ddce87356c11d4d9e8fa394bc33c7e75597d6110bf77a01be7e400f368c345eacd5e766d8df73538f9833b0f21cf422155
+  metadata.gz: 9e8d9e9803f74368d9379c3b876e816ae8bb4dbfb8f2357e3cf95717d0dacd66e45e301bfbbaecb7e6e1e517e13abf122fc9e5d72834a8d09bdf65fa117c4766
+  data.tar.gz: 318fa95ea899418e543bf103031bed282c5bd692b43e2f419c039dbc3ea29483490d8552441b174d245b019383de2738ee5356d1898a3f78625bd15bb2ada85c

data/lib/sequel_deep_dup.rb

@@ -28,19 +28,21 @@ module Sequel
         end
 
         def dup_associations instance, copy, includes = nil
-          includes &&= includes.map { |item| [*item].flatten }
+          includes &&= normalize_graph(includes)
           associations = instance.class.associations
 
-          ([*includes].map{ |i| i.first } - associations).each do |assoc|
-            raise(Error, "no association named #{assoc} for #{instance}")
+          if includes
+            (includes.keys - associations).each do |assoc|
+              raise(Error, "no association named #{assoc} for #{instance}")
+            end
           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])
+                next unless includes.has_key?( refl_name = refl[:name] )
+                instantiate_associated copy, refl, rec, includes[refl_name]
               else
                 next copy.values.delete(refl[:key]) if refl[:type] == :many_to_one
                 instantiate_associated(copy, refl, rec, nil)
@@ -49,6 +51,17 @@ module Sequel
           end
         end
 
+        def normalize_graph(*enum)
+          enum.inject({}) do |hash, assoc|
+            case assoc
+            when Symbol then hash[assoc] = {}
+            when Hash   then assoc.each { |k, v| hash[k] = normalize_graph(v) }
+            else hash.merge!(normalize_graph(*assoc) || next)
+            end
+            hash
+          end
+        end
+
         private
         def instantiate_associated copy, reflection, record, associations
           return if omit_records.detect { |to_omit| record.pk == to_omit.pk && record.class == to_omit.class }

data/lib/sequel_deep_dup/version.rb

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

data/spec/deep_dup_spec.rb

@@ -18,12 +18,12 @@ describe Sequel::Plugins::DeepDup do
     describe 'duplication plain record' do
       context 'with regular pk' do
         it { program_copy.name.should == 'CS' }
-        it { program_copy.pk.should be_nil } 
+        it { program_copy.pk.should be_nil }
       end
 
       context 'with composite pks' do
-        it { program_copy.should be_new } 
-        it { enrollment_copy.pk.should == [nil, nil] } 
+        it { program_copy.should be_new }
+        it { enrollment_copy.pk.should == [nil, nil] }
         it { enrollment_copy.should be_new }
       end
     end
@@ -119,10 +119,12 @@ describe Sequel::Plugins::DeepDup do
   describe 'restrictions' do
     before do
       Program.plugin :deep_dup
+      Course.plugin :deep_dup
     end
 
     let!(:program) { create :program, :with_graph }
 
+
     describe 'validate graph' do
       it { Course.count.should be 3 }
       it { Assignment.count.should be 9 }
@@ -137,7 +139,7 @@ describe Sequel::Plugins::DeepDup 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 
+    end
 
     describe 'restricts to children of children' do
       let(:program_copy) { program.deep_dup :courses => :assignments }
@@ -158,8 +160,67 @@ describe Sequel::Plugins::DeepDup do
       it { expect { program_copy.save }.not_to change { Category.count } }
     end
 
+    describe 'allows different graphs for same record with different graph format' do
+      let(:course) { program.courses.first }
+
+      let(:course_copy) { course.deep_dup({:categories => [], :enrollments => {:student => [:profile, :account]}}, :assignments) }
+      it { expect { course_copy.save }.to change { Course.count }.by(1) }
+      it { expect { course_copy.save }.to change { Assignment.count }.by(3) }
+      it { expect { course_copy.save }.to change { Enrollment.count }.by(3) }
+      it { expect { course_copy.save }.to change { Student.count }.by(3) }
+      it { expect { course_copy.save }.to change { Account.count }.by(3) }
+      it { expect { course_copy.save }.to change { Profile.count }.by(3) }
+      it { expect { course_copy.save }.to change { DB[:course_categories].count }.by(3) }
+      it { expect { course_copy.save }.not_to change { Category.count } }
+    end
+
+    describe 'normalizing graph' do
+      let(:dupper) { Sequel::Plugins::DeepDup::DeepDupper.new(nil) }
+
+      it 'maps symbols' do
+        parsed = dupper.normalize_graph( [:course, :assignments, :categories] )
+        parsed.should == {:course => {}, :assignments => {}, :categories => {}}
+      end
+
+      it 'maps symbols followed by hash' do
+        parsed = dupper.normalize_graph( [:course, {:assignments => :categories}] )
+        parsed.should == {:course => {}, :assignments => {:categories => {}}}
+      end
+
+      it 'omits processing a hash' do
+        parsed = dupper.normalize_graph( :assignments => [], :categories => [], :enrollments => [:student] )
+        parsed.should == { :assignments => {}, :categories => {}, :enrollments => {:student => {}} }
+      end
+
+      it 'maps array of symbol and hashes' do
+        parsed = dupper.normalize_graph( [:assignments, {:categories => [], :enrollments => [:student]}] )
+        parsed.should == {:assignments => {}, :categories => {}, :enrollments => {:student => {}}}
+      end
+
+      it 'maps array of symbol and hashes with nested assoc array' do
+        parsed = dupper.normalize_graph( [:assignments, {:enrollments => [:student, :course]}, :tags] )
+        parsed.should ==  {:assignments => {}, :enrollments => {:student => {}, :course => {}}, :tags => {}}
+      end
+
+      it 'maps nested hashes' do
+        parsed = dupper.normalize_graph([{:courses => [:assignments, {:enrollments => {:student => [:profile, :account]}}, :categories]}])
+        parsed.should == {
+          :courses => {
+            :assignments => {},
+            :enrollments => {
+              :student => {
+                :profile => {},
+                :account => {}
+              }
+            },
+            :categories => {}
+          }
+        }
+      end
+    end
+
     it 'raises exception when association present in graph is not defined in model' do
-      expect { program.deep_dup :potatoes }.to raise_error(Sequel::Error) 
+      expect { program.deep_dup :potatoes }.to raise_error(Sequel::Error)
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sequel_deep_dup
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.2.2
 platform: ruby
 authors:
 - macario
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-04-09 00:00:00.000000000 Z
+date: 2014-04-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler