hydra-pcdm 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a31e7e8302b6fa6566390c103c94e588199f2d50
-  data.tar.gz: 35d89b527d58013dd4c4aa0477a59ac6a0235d56
+  metadata.gz: 6ddcd3f1a0e883fa81ac51d63cee4a16359b54c7
+  data.tar.gz: f569047389d44e967676fcc9fd6447536a3abbe7
 SHA512:
-  metadata.gz: 95ea6fa959fb711e4ca1e5a32e92e3e834d42987c00232353111da00bd7a5a5fb50dcced29ff87e3f5d3bbd4e4a08373a1337bac8acb4e1ba37ca3134f5bc417
-  data.tar.gz: 3549b065504e7bed1b1b8ecdbe941618b2000c73006b0cfe471e0250f79b5f4ec70ff9ea6dbbfb31d09ea73d32623378f71b13211071c29011eadc8ce89bc60a
+  metadata.gz: d409cb3d8f26a222cb90691d892bd24aed2451a323f238ad205d2843740b7023d461f539a8c44b20fd156d3a83e372b0e41e0fc705a28f88a6cb0ee2b1697153
+  data.tar.gz: 4dd1dcaf0e9cec180f14b35ebedc1bd10132ca1586eca54af825870c3333d3c7fc200ccd1e9d78c4392bec8b45c26c2c819ca1b0dbad2c34ba3975eadb6335b4

data/Gemfile

@@ -8,5 +8,7 @@ group :development, :test do
   gem 'pry-byebug' unless ENV['CI']
 end
 
+gem 'activefedora-aggregation', github: 'projecthydra-labs/activefedora-aggregation'
+
 # Specify your gem's dependencies in hydra-pcdm.gemspec
 gemspec

data/hydra-pcdm.gemspec

@@ -19,8 +19,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ['lib']
 
-  spec.add_dependency 'active-fedora', '>= 9.4.1'
-  spec.add_dependency 'activefedora-aggregation', '~> 0.4'
+  spec.add_dependency 'activefedora-aggregation', '~> 0.5'
   spec.add_dependency 'mime-types', '>= 1'
 
   spec.add_development_dependency 'bundler', '~> 1.6'

data/lib/hydra/pcdm/collection_indexer.rb

@@ -2,8 +2,10 @@ module Hydra::PCDM
   class CollectionIndexer < ObjectIndexer
     def generate_solr_document
       super.tap do |solr_doc|
-        solr_doc['member_ids_ssim'] = object.member_ids
-        solr_doc['collection_ids_ssim'] = object.collection_ids
+        solr_doc['member_ids_ssim'] ||= []
+        solr_doc['member_ids_ssim'] += object.member_ids
+        solr_doc['member_ids_ssim'].uniq!
+        solr_doc['collection_ids_ssim'] = object.ordered_collection_ids
       end
     end
   end

data/lib/hydra/pcdm/models/concerns/collection_behavior.rb

@@ -16,8 +16,6 @@ module Hydra::PCDM
     included do
       type Vocab::PCDMTerms.Collection
       include ::Hydra::PCDM::PcdmBehavior
-
-      filters_association :members, as: :collections, condition: :pcdm_collection?
     end
 
     module ClassMethods
@@ -29,6 +27,22 @@ module Hydra::PCDM
       end
     end
 
+    def collections
+      members.select(&:pcdm_collection?)
+    end
+
+    def collection_ids
+      members.select(&:pcdm_collection?).map(&:id)
+    end
+
+    def ordered_collections
+      ordered_members.to_a.select(&:pcdm_collection?)
+    end
+
+    def ordered_collection_ids
+      ordered_collections.map(&:id)
+    end
+
     def pcdm_object?
       false
     end
@@ -39,17 +53,12 @@ module Hydra::PCDM
 
     def child_collections
       warn '[DEPRECATION] `child_collections` is deprecated in Hydra::PCDM.  Please use `collections` instead.  This has a target date for removal of 10-31-2015'
-      collections
-    end
-
-    def child_collections=(new_collections)
-      warn '[DEPRECATION] `child_collections=` is deprecated in Hydra::PCDM.  Please use `collections=` instead.  This has a target date for removal of 10-31-2015'
-      self.collections = new_collections
+      ordered_collections
     end
 
     def child_collection_ids
       warn '[DEPRECATION] `child_collection_ids` is deprecated in Hydra::PCDM.  Please use `collection_ids` instead.  This has a target date for removal of 10-31-2015'
-      collection_ids
+      ordered_collection_ids
     end
   end
 end

data/lib/hydra/pcdm/models/concerns/object_behavior.rb

@@ -40,7 +40,7 @@ module Hydra::PCDM
     end
 
     def in_objects
-      aggregated_by.select(&:pcdm_object?)
+      ordered_by.select(&:pcdm_object?).to_a
     end
 
     def parent_objects

data/lib/hydra/pcdm/models/concerns/pcdm_behavior.rb

@@ -2,10 +2,11 @@ module Hydra::PCDM
   module PcdmBehavior
     extend ActiveSupport::Concern
     included do
-      aggregates :members, predicate: Vocab::PCDMTerms.hasMember,
-                           class_name: 'ActiveFedora::Base',
-                           type_validator: type_validator
-      filters_association :members, as: :objects, condition: :pcdm_object?
+      ordered_aggregation :members,
+                          has_member_relation: Vocab::PCDMTerms.hasMember,
+                          class_name: 'ActiveFedora::Base',
+                          type_validator: type_validator,
+                          through: :list_source
       indirectly_contains :related_objects, has_member_relation: RDF::Vocab::ORE.aggregates,
                                             inserted_content_relation: RDF::Vocab::ORE.proxyFor, class_name: 'ActiveFedora::Base',
                                             through: 'ActiveFedora::Aggregation::Proxy', foreign_key: :target,
@@ -23,16 +24,40 @@ module Hydra::PCDM
     end
 
     def member_of
-      aggregated_by
+      ActiveFedora::Base.where(member_ids_ssim: id)
+    end
+
+    def member_ids
+      members.map(&:id)
+    end
+
+    def ordered_member_ids
+      ordered_member_proxies.map(&:target_id)
+    end
+
+    def objects
+      members.select(&:pcdm_object?)
+    end
+
+    def object_ids
+      members.select(&:pcdm_object?).map(&:id)
+    end
+
+    def ordered_objects
+      ordered_members.to_a.select(&:pcdm_object?)
+    end
+
+    def ordered_object_ids
+      ordered_objects.map(&:id)
     end
 
     def parents
-      warn '[DEPRECATION] `parents` is deprecated in Hydra::PCDM.  Please use `member_of` instead.  This has a target date for removal of 10-31-2015'
-      member_of
+      warn '[DEPRECATION] `parents` is deprecated in Hydra::PCDM.  Please use `ordered_by` instead.  This has a target date for removal of 10-31-2015'
+      ordered_by.to_a
     end
 
     def in_collections
-      aggregated_by.select(&:pcdm_collection?)
+      member_of.select(&:pcdm_collection?).to_a
     end
 
     def parent_collections
@@ -59,12 +84,7 @@ module Hydra::PCDM
 
     def child_objects
       warn '[DEPRECATION] `child_objects` is deprecated in Hydra::PCDM.  Please use `objects` instead.  This has a target date for removal of 10-31-2015'
-      objects
-    end
-
-    def child_objects=(new_objects)
-      warn '[DEPRECATION] `child_objects=` is deprecated in Hydra::PCDM.  Please use `objects=` instead.  This has a target date for removal of 10-31-2015'
-      self.objects = new_objects
+      ordered_objects
     end
 
     def child_object_ids

data/lib/hydra/pcdm/object_indexer.rb

@@ -2,7 +2,10 @@ module Hydra::PCDM
   class ObjectIndexer < ActiveFedora::IndexingService
     def generate_solr_document
       super.tap do |solr_doc|
-        solr_doc['object_ids_ssim'] = object.object_ids
+        solr_doc['member_ids_ssim'] ||= []
+        solr_doc['member_ids_ssim'] += object.member_ids
+        solr_doc['member_ids_ssim'].uniq!
+        solr_doc['object_ids_ssim'] = object.ordered_object_ids
       end
     end
   end

data/lib/hydra/pcdm/version.rb

@@ -1,5 +1,5 @@
 module Hydra
   module PCDM
-    VERSION = '0.2.0'
+    VERSION = '0.3.0'
   end
 end

data/spec/hydra/pcdm/collection_indexer_spec.rb

@@ -8,8 +8,8 @@ describe Hydra::PCDM::CollectionIndexer do
   let(:indexer) { described_class.new(collection) }
 
   before do
-    allow(collection).to receive(:collection_ids).and_return(collection_ids)
-    allow(collection).to receive(:object_ids).and_return(object_ids)
+    allow(collection).to receive(:ordered_collection_ids).and_return(collection_ids)
+    allow(collection).to receive(:ordered_object_ids).and_return(object_ids)
     allow(collection).to receive(:member_ids).and_return(member_ids)
   end
 

data/spec/hydra/pcdm/models/collection_spec.rb

@@ -10,33 +10,63 @@ describe Hydra::PCDM::Collection do
   let(:object2) { Hydra::PCDM::Object.new }
   let(:object3) { Hydra::PCDM::Object.new }
 
+  describe '#collections' do
+    it 'returns non-ordered collections' do
+      collection1.members += [collection2, collection3]
+      collection1.ordered_members << collection4
+
+      expect(collection1.collections).to eq [collection2, collection3, collection4]
+      expect(collection1.ordered_collections).to eq [collection4]
+    end
+  end
+
+  describe '#collection_ids' do
+    it 'returns IDs of non-ordered collections' do
+      collection1.members += [collection2, collection3]
+      collection1.ordered_members << collection4
+
+      expect(collection1.collection_ids).to eq [collection2.id, collection3.id, collection4.id]
+    end
+  end
+
+  describe '#objects' do
+    it 'returns non-ordered objects' do
+      collection1.members += [object1, object2]
+      collection1.ordered_members << object3
+
+      expect(collection1.objects).to eq [object1, object2, object3]
+      expect(collection1.ordered_objects).to eq [object3]
+    end
+  end
+
+  describe '#object_ids' do
+    it 'returns IDs of non-ordered objects' do
+      collection1.members += [object1, object2]
+      collection1.ordered_members << object3
+
+      expect(collection1.object_ids).to eq [object1.id, object2.id, object3.id]
+    end
+  end
+
   describe 'adding collections' do
     describe 'with acceptable inputs' do
       subject { described_class.new }
-      it 'adds collections, sub-collections, and repeating collections' do
-        subject.collections << collection1      # first add
-        subject.collections << collection2      # second add to same collection
-        subject.collections << collection1      # repeat a collection
-        collection1.collections << collection3  # add sub-collection
-        expect(subject.collections).to eq [collection1, collection2, collection1]
-        expect(collection1.collections).to eq [collection3]
-      end
       it 'adds an object to collection with collections and objects' do
-        subject.members << collection1
-        subject.members << collection2
-        subject.members << object1
-        subject.members << object2
-        subject.members << collection3
-        expect(subject.members).to eq [collection1, collection2, object1, object2, collection3]
-        expect(subject.collections).to eq [collection1, collection2, collection3]
-        expect(subject.objects).to eq [object1, object2]
+        subject.ordered_members << collection1
+        subject.ordered_members << collection2
+        subject.ordered_members << object1
+        subject.ordered_members << object2
+        subject.ordered_members << collection3
+        expect(subject.ordered_members).to eq [collection1, collection2, object1, object2, collection3]
+        expect(subject.ordered_collections).to eq [collection1, collection2, collection3]
+        expect(subject.ordered_objects).to eq [object1, object2]
       end
     end
 
     describe '#in_collection_ids' do
       it 'returns the IDs of the parent' do
-        subject.members << object1
-        subject.members << collection1
+        subject.ordered_members << object1
+        subject.ordered_members << collection1
         subject.save
         expect(object1.in_collection_ids).to eq [subject.id]
         expect(collection1.in_collection_ids).to eq [subject.id]
@@ -53,13 +83,13 @@ describe Hydra::PCDM::Collection do
       let(:kollection1) { Kollection.new }
 
       it 'accepts implementing collection as a child' do
-        subject.collections << kollection1
-        expect(subject.collections).to eq [kollection1]
+        subject.ordered_members << kollection1
+        expect(subject.ordered_collections).to eq [kollection1]
       end
 
       it 'accepts implementing collection as a parent' do
-        kollection1.collections << collection1
-        expect(kollection1.collections).to eq [collection1]
+        kollection1.ordered_members << collection1
+        expect(kollection1.ordered_collections).to eq [collection1]
       end
     end
 
@@ -72,13 +102,13 @@ describe Hydra::PCDM::Collection do
       let(:cullection1) { Cullection.new }
 
       it 'accepts extending collection as a child' do
-        subject.collections << cullection1
-        expect(subject.collections).to eq [cullection1]
+        subject.ordered_members << cullection1
+        expect(subject.ordered_collections).to eq [cullection1]
       end
 
       it 'accepts extending collection as a parent' do
-        cullection1.collections << collection1
-        expect(cullection1.collections).to eq [collection1]
+        cullection1.ordered_members << collection1
+        expect(cullection1.ordered_collections).to eq [collection1]
       end
     end
 
@@ -91,25 +121,23 @@ describe Hydra::PCDM::Collection do
       end
 
       context 'that are unacceptable child collections' do
-        let(:error_type1)    { ArgumentError }
-        let(:error_message1) { 'Hydra::PCDM::Object with ID:  was expected to pcdm_collection?, but it was false' }
-        let(:error_type2)    { NoMethodError }
-        let(:error_message2) { /undefined method `pcdm_collection\?' for .*/ }
+        let(:error_type1)    { ActiveFedora::AssociationTypeMismatch }
+        let(:error_message1) { /ActiveFedora::Base\(#\d+\) expected, got String\(#[\d]+\)/ }
+        let(:error_type2)    { ActiveFedora::AssociationTypeMismatch }
+        let(:error_message2) { /(<ActiveFedora::Base:[\d\s\w]{16}>|\s*) is not a PCDM object or collection./ }
+        let(:error_type3)    { ActiveFedora::AssociationTypeMismatch }
+        let(:error_message3) { /ActiveFedora::Base\(#\d+\) expected, got Hydra::PCDM::File\(#[\d]+\)/ }
 
-        it 'raises an error when trying to aggregate Hydra::PCDM::Objects in collections aggregation' do
-          expect { collection1.collections << @object101 }.to raise_error(error_type1, error_message1)
+        it 'raises an error when trying to aggregate Hydra::PCDM::Files in members aggregation' do
+          expect { collection1.ordered_members << @file101 }.to raise_error(error_type3, error_message3)
         end
 
-        it 'raises an error when trying to aggregate Hydra::PCDM::Files in collections aggregation' do
-          expect { collection1.collections << @file101 }.to raise_error(error_type2, error_message2)
+        it 'raises an error when trying to aggregate non-PCDM objects in members aggregation' do
+          expect { collection1.ordered_members << @non_pcdm_object }.to raise_error(error_type1, error_message1)
         end
 
-        it 'raises an error when trying to aggregate non-PCDM objects in collections aggregation' do
-          expect { collection1.collections << @non_pcdm_object }.to raise_error(error_type2, error_message2)
-        end
-
-        it 'raises an error when trying to aggregate AF::Base objects in collections aggregation' do
-          expect { collection1.collections << @af_base_object }.to raise_error(error_type2, error_message2)
+        it 'raises an error when trying to aggregate AF::Base objects in members aggregation' do
+          expect { collection1.ordered_members << @af_base_object }.to raise_error(error_type2, error_message2)
         end
       end
     end
@@ -120,35 +148,35 @@ describe Hydra::PCDM::Collection do
 
       context 'when the source collection is the same' do
         it 'raises an error' do
-          expect { subject.collections << subject }.to raise_error(error_type, error_message)
+          expect { subject.ordered_members << subject }.to raise_error(error_type, error_message)
         end
       end
 
       before do
-        subject.collections << collection1
+        subject.ordered_members << collection1
       end
 
       it 'raises and error' do
-        expect { collection1.collections << subject }.to raise_error(error_type, error_message)
+        expect { collection1.ordered_members << subject }.to raise_error(error_type, error_message)
       end
 
       context 'with more ancestors' do
         before do
-          collection1.collections << collection2
+          collection1.ordered_members << collection2
         end
 
         it 'raises an error' do
-          expect { collection2.collections << subject }.to raise_error(error_type, error_message)
+          expect { collection2.ordered_members << subject }.to raise_error(error_type, error_message)
         end
 
         context 'with a more complicated example' do
           before do
-            collection2.collections << collection3
+            collection2.ordered_members << collection3
           end
 
           it 'raises errors' do
-            expect { collection3.collections << subject }.to raise_error(error_type, error_message)
-            expect { collection3.collections << collection1 }.to raise_error(error_type, error_message)
+            expect { collection3.ordered_members << subject }.to raise_error(error_type, error_message)
+            expect { collection3.ordered_members << collection1 }.to raise_error(error_type, error_message)
           end
         end
       end
@@ -160,52 +188,52 @@ describe Hydra::PCDM::Collection do
 
     context 'when it is the only collection' do
       before do
-        subject.members << collection1
-        expect(subject.collections).to eq [collection1]
+        subject.ordered_members << collection1
+        expect(subject.ordered_collections).to eq [collection1]
       end
 
       it 'removes collection while changes are in memory' do
-        expect(subject.members.delete collection1).to eq [collection1]
-        expect(subject.collections).to eq []
+        subject.ordered_member_proxies.delete_at(0)
+        expect(subject.ordered_collections).to eq []
       end
 
       it 'removes collection only when objects and all changes are in memory' do
-        subject.members << object1
-        subject.members << object2
-        expect(subject.members.delete collection1).to eq [collection1]
-        expect(subject.collections).to eq []
-        expect(subject.objects).to eq [object1, object2]
+        subject.ordered_members << object1
+        subject.ordered_members << object2
+        subject.ordered_member_proxies.delete_at(0)
+        expect(subject.ordered_collections).to eq []
+        expect(subject.ordered_objects).to eq [object1, object2]
       end
     end
 
     context 'when multiple collections' do
       before do
-        subject.members << collection1
-        subject.members << collection2
-        subject.members << collection3
-        expect(subject.collections).to eq [collection1, collection2, collection3]
+        subject.ordered_members << collection1
+        subject.ordered_members << collection2
+        subject.ordered_members << collection3
+        expect(subject.ordered_collections).to eq [collection1, collection2, collection3]
       end
 
       it 'removes first collection when changes are in memory' do
-        expect(subject.members.delete collection1).to eq [collection1]
-        expect(subject.collections).to eq [collection2, collection3]
+        subject.ordered_member_proxies.delete_at(0)
+        expect(subject.ordered_collections).to eq [collection2, collection3]
       end
 
       it 'removes last collection when changes are in memory' do
-        expect(subject.members.delete collection3).to eq [collection3]
-        expect(subject.collections).to eq [collection1, collection2]
+        subject.ordered_member_proxies.delete_at(2)
+        expect(subject.ordered_collections).to eq [collection1, collection2]
       end
 
       it 'removes middle collection when changes are in memory' do
-        expect(subject.members.delete collection2).to eq [collection2]
-        expect(subject.collections).to eq [collection1, collection3]
+        subject.ordered_member_proxies.delete_at(1)
+        expect(subject.ordered_collections).to eq [collection1, collection3]
       end
 
       it 'removes middle collection when changes are saved' do
-        expect(subject.collections).to eq [collection1, collection2, collection3]
+        expect(subject.ordered_collections).to eq [collection1, collection2, collection3]
         subject.save
-        expect(subject.members.delete collection2).to eq [collection2]
-        expect(subject.collections).to eq [collection1, collection3]
+        subject.ordered_member_proxies.delete_at(1)
+        expect(subject.ordered_collections).to eq [collection1, collection3]
       end
     end
     context 'when collection is missing' do
@@ -214,14 +242,14 @@ describe Hydra::PCDM::Collection do
       end
 
       it 'and multiple sub-collections should return empty array when changes are in memory' do
-        subject.members << collection1
-        subject.members << collection3
+        subject.ordered_members << collection1
+        subject.ordered_members << collection3
         expect(subject.members.delete collection2).to eq []
       end
 
       it 'returns empty array when changes are saved' do
-        subject.members << collection1
-        subject.members << collection3
+        subject.ordered_members << collection1
+        subject.ordered_members << collection3
         subject.save
         expect(subject.members.delete collection2).to eq []
       end
@@ -231,19 +259,19 @@ describe Hydra::PCDM::Collection do
   describe 'adding objects' do
     context 'with acceptable inputs' do
       it 'adds objects, sub-collections, and repeating collections' do
-        subject.objects << object1      # first add
-        subject.objects << object2      # second add to same collection
-        subject.objects << object1      # repeat an object
-        expect(subject.objects).to eq [object1, object2, object1]
+        subject.ordered_members << object1      # first add
+        subject.ordered_members << object2      # second add to same collection
+        subject.ordered_members << object1      # repeat an object
+        expect(subject.ordered_members).to eq [object1, object2, object1]
       end
 
       context 'with collections and objects' do
         it 'adds an object to collection with collections and objects' do
-          subject.objects << object1
-          subject.collections << collection1
-          subject.collections << collection2
-          subject.objects << object2
-          expect(subject.objects).to eq [object1, object2]
+          subject.ordered_members << object1
+          subject.ordered_members << collection1
+          subject.ordered_members << collection2
+          subject.ordered_members << object2
+          expect(subject.ordered_objects).to eq [object1, object2]
         end
       end
 
@@ -257,8 +285,8 @@ describe Hydra::PCDM::Collection do
         let(:ahbject1) { Ahbject.new }
 
         it 'accepts implementing object as a child' do
-          subject.objects << ahbject1
-          expect(subject.objects).to eq [ahbject1]
+          subject.ordered_members << ahbject1
+          expect(subject.ordered_objects).to eq [ahbject1]
         end
       end
 
@@ -271,168 +299,13 @@ describe Hydra::PCDM::Collection do
         let(:awbject1) { Awbject.new }
 
         it 'accepts extending object as a child' do
-          subject.objects << awbject1
-          expect(subject.objects).to eq [awbject1]
-        end
-      end
-    end
-
-    context 'with unacceptable inputs' do
-      before(:all) do
-        @file101         = Hydra::PCDM::File.new
-        @non_pcdm_object = "I'm not a PCDM object"
-        @af_base_object  = ActiveFedora::Base.new
-      end
-
-      context 'with unacceptable objects' do
-        let(:error_type1)    { ArgumentError }
-        let(:error_message1) { 'Hydra::PCDM::Collection with ID:  was expected to pcdm_object?, but it was false' }
-        let(:error_type2)    { NoMethodError }
-        let(:error_message2) { /undefined method `pcdm_object\?' for .*/ }
-
-        it 'raises an error when trying to aggregate Hydra::PCDM::Collection in objects aggregation' do
-          expect { collection1.objects << collection2 }.to raise_error(error_type1, error_message1)
-        end
-
-        it 'raises an error when trying to aggregate Hydra::PCDM::Files in objects aggregation' do
-          expect { collection1.objects << @file101 }.to raise_error(error_type2, error_message2)
-        end
-
-        it 'raises an error when trying to aggregate non-PCDM objects in objects aggregation' do
-          expect { collection1.objects << @non_pcdm_object }.to raise_error(error_type2, error_message2)
-        end
-
-        it 'raises an error when trying to aggregate AF::Base objects in objects aggregation' do
-          expect { collection1.objects << @af_base_object }.to raise_error(error_type2, error_message2)
+          subject.ordered_members << awbject1
+          expect(subject.ordered_objects).to eq [awbject1]
         end
       end
     end
   end
 
-  describe 'removing objects' do
-    context 'when it is the only object' do
-      before do
-        subject.objects << object1
-        expect(subject.objects).to eq [object1]
-      end
-
-      it 'removes object while changes are in memory' do
-        expect(subject.objects.delete object1).to eq [object1]
-        expect(subject.objects).to eq []
-      end
-
-      it 'removes object only when collections and all changes are in memory' do
-        subject.collections << collection1
-        subject.collections << collection2
-        expect(subject.objects.delete object1).to eq [object1]
-        expect(subject.objects).to eq []
-        expect(subject.collections).to eq [collection1, collection2]
-      end
-    end
-
-    context 'when multiple objects' do
-      let(:object3) { Hydra::PCDM::Object.new }
-
-      before do
-        subject.objects << object1
-        subject.objects << object2
-        subject.objects << object3
-        expect(subject.objects).to eq [object1, object2, object3]
-      end
-
-      it 'removes first object when changes are in memory' do
-        expect(subject.objects.delete object1).to eq [object1]
-        expect(subject.objects).to eq [object2, object3]
-      end
-
-      it 'removes middle object when changes are in memory' do
-        expect(subject.objects.delete object2).to eq [object2]
-        expect(subject.objects).to eq [object1, object3]
-      end
-
-      it 'removes last object when changes are in memory' do
-        expect(subject.objects.delete object3).to eq [object3]
-        expect(subject.objects).to eq [object1, object2]
-      end
-      it 'removes middle object when changes are saved' do
-        expect(subject.objects.delete object2).to eq [object2]
-        expect(subject.objects).to eq [object1, object3]
-        subject.save
-        expect(subject.reload.objects).to eq [object1, object3]
-      end
-    end
-
-    context 'when object repeats' do
-      let(:object3) { Hydra::PCDM::Object.new }
-      let(:object4) { Hydra::PCDM::Object.new }
-      let(:object5) { Hydra::PCDM::Object.new }
-
-      before do
-        subject.objects << object1
-        subject.objects << object2
-        subject.objects << object3
-        subject.objects << object2
-        subject.objects << object4
-        subject.objects << object2
-        subject.objects << object5
-        expect(subject.objects).to eq [object1, object2, object3, object2, object4, object2, object5]
-      end
-
-      # TODO: pending implementation of multiple objects
-
-      it 'removes first occurrence when changes in memory' do
-        expect(subject.objects.delete object2).to eq [object2]
-        expect(subject.objects).to eq [object1, object3, object4, object5]
-      end
-
-      it 'removes last occurrence when changes in memory' do
-        skip('pending resolution of AF-agg 46 and PCDM 102') do
-          expect(subject.objects.delete object2, -1).to eq object2
-          expect(subject.objects).to eq [object1, object2, object3, object2, object4, object5]
-        end
-      end
-
-      it 'removes nth occurrence when changes in memory' do
-        skip('pending resolution of AF-agg 46 and PCDM 102') do
-          expect(subject.objects.delete object2, 2).to eq object2
-          expect(subject.objects).to eq [object1, object2, object3, object4, object2, object5]
-        end
-      end
-      it 'removes nth occurrence when changes are saved' do
-        skip('pending resolution of AF-agg 46 and PCDM 102') do
-          expect(subject.objects).to eq [object1, object2, object3, object2, object4, object2, object5]
-          subject.save
-          expect(subject.reload.objects).to eq [object1, object2, object3, object2, object4, object2, object5]
-
-          expect(subject.objects.delete object2, 2).to eq object2
-          subject.save
-          expect(subject.reload.objects).to eq [object1, object2, object3, object4, object2, object5]
-        end
-      end
-    end
-
-    context 'when object is missing' do
-      let(:object3) { Hydra::PCDM::Object.new }
-
-      it 'and 0 objects in collection should return empty array' do
-        expect(subject.objects.delete object1).to eq []
-      end
-
-      it 'and multiple objects in collection should return empty array when changes are in memory' do
-        subject.objects << object1
-        subject.objects << object2
-        expect(subject.objects.delete object3).to eq []
-      end
-
-      it 'returns empty array when changes are saved' do
-        subject.objects << object1
-        subject.objects << object2
-        subject.save
-        expect(subject.reload.objects.delete object3).to eq []
-      end
-    end
-  end
-
   describe 'add related objects' do
     context 'with acceptable collections' do
       it 'adds objects to the related object set' do
@@ -529,14 +402,14 @@ describe Hydra::PCDM::Collection do
       end
 
       it 'removes related object only when objects & collections and all changes are in memory' do
-        subject.collections << collection1
-        subject.collections << collection2
-        subject.objects << object3
-        subject.objects << object2
+        subject.ordered_members << collection1
+        subject.ordered_members << collection2
+        subject.ordered_members << object3
+        subject.ordered_members << object2
         expect(subject.related_objects.delete object1).to eq [object1]
         expect(subject.related_objects).to eq []
-        expect(subject.collections).to eq [collection1, collection2]
-        expect(subject.objects).to eq [object3, object2]
+        expect(subject.ordered_collections).to eq [collection1, collection2]
+        expect(subject.ordered_objects).to eq [object3, object2]
       end
     end
 
@@ -581,10 +454,10 @@ describe Hydra::PCDM::Collection do
       end
 
       it 'returns empty array when 0 related objects, but has collections and objects and changes in memory' do
-        subject.members << collection1
-        subject.members << collection2
-        subject.members << object1
-        subject.members << object2
+        subject.ordered_members << collection1
+        subject.ordered_members << collection2
+        subject.ordered_members << object1
+        subject.ordered_members << object2
         expect(subject.related_objects.delete object1).to eq []
       end
 
@@ -625,67 +498,13 @@ describe Hydra::PCDM::Collection do
     end
   end
 
-  describe '#collections=' do
-    it 'aggregates collections' do
-      collection1.collections = [collection2, collection3]
-      expect(collection1.collections).to eq [collection2, collection3]
-    end
-  end
-
-  describe '#collections<<' do
-    before do
-      collection1.collections = [collection2]
-    end
-    it 'aggregates collections' do
-      collection1.collections << collection3
-      expect(collection1.collections).to eq [collection2, collection3]
-    end
-  end
-
-  describe '#collections+=' do
-    before do
-      collection1.collections = [collection2]
-    end
-    it 'aggregates collections' do
-      collection1.collections += [collection3, collection4]
-      expect(collection1.collections).to eq [collection2, collection3, collection4]
-    end
-  end
-
-  describe '#objects=' do
-    it 'aggregates objects' do
-      collection1.objects = [object1, object2]
-      expect(collection1.objects).to eq [object1, object2]
-    end
-  end
-
-  describe '#objects<<' do
-    before do
-      collection1.objects = [object1]
-    end
-    it 'appends object to aggregated objects' do
-      collection1.objects << object2
-      expect(collection1.objects).to eq [object1, object2]
-    end
-  end
-
-  describe '#objects+=' do
-    before do
-      collection1.objects = [object1]
-    end
-    it 'appends object to aggregated objects' do
-      collection1.objects += [object2, object3]
-      expect(collection1.objects).to eq [object1, object2, object3]
-    end
-  end
-
-  describe '#collection_ids' do
+  describe '#ordered_collection_ids' do
     let(:child1) { described_class.new(id: '1') }
     let(:child2) { described_class.new(id: '2') }
     let(:object) { described_class.new }
-    before { object.collections = [child1, child2] }
+    before { object.ordered_members = [child1, child2] }
 
-    subject { object.collection_ids }
+    subject { object.ordered_collection_ids }
 
     it { is_expected.to eq %w(1 2) }
   end
@@ -694,31 +513,31 @@ describe Hydra::PCDM::Collection do
     subject { described_class.new }
 
     it 'returns empty array when no members' do
-      expect(subject.collections).to eq []
-      expect(subject.objects).to eq []
+      expect(subject.ordered_collections).to eq []
+      expect(subject.ordered_objects).to eq []
     end
 
     it 'collections should return empty array when only objects are aggregated' do
-      subject.members << object1
-      subject.members << object2
-      expect(subject.collections).to eq []
+      subject.ordered_members << object1
+      subject.ordered_members << object2
+      expect(subject.ordered_collections).to eq []
     end
 
     it 'objects should return empty array when only collections are aggregated' do
-      subject.members << collection1
-      subject.members << collection2
-      expect(subject.objects).to eq []
+      subject.ordered_members << collection1
+      subject.ordered_members << collection2
+      expect(subject.ordered_objects).to eq []
     end
 
     context 'should only contain members of the correct type' do
       it 'returns only collections' do
-        subject.collections << collection1
-        subject.members << collection2
-        subject.objects << object1
-        subject.members << object2
-        expect(subject.collections).to eq [collection1, collection2]
-        expect(subject.objects).to eq [object1, object2]
-        expect(subject.members).to eq [collection1, collection2, object1, object2]
+        subject.ordered_members << collection1
+        subject.ordered_members << collection2
+        subject.ordered_members << object1
+        subject.ordered_members << object2
+        expect(subject.ordered_collections).to eq [collection1, collection2]
+        expect(subject.ordered_objects).to eq [object1, object2]
+        expect(subject.ordered_members).to eq [collection1, collection2, object1, object2]
       end
     end
   end
@@ -730,20 +549,17 @@ describe Hydra::PCDM::Collection do
       @collection1 = described_class.new
       @collection2 = described_class.new
       @collection =  described_class.new
-      @collection1.collections << @collection
-      @collection2.collections << @collection
-      allow(@collection).to receive(:id).and_return('banana')
-      proxies = [
-        build_proxy(container: @collection1),
-        build_proxy(container: @collection2)
-      ]
-      allow(ActiveFedora::Aggregation::Proxy).to receive(:where).with(proxyFor_ssim: @collection.id).and_return(proxies)
+      @collection1.members << @collection
+      @collection2.members << @collection
+      @collection.save
+      @collection1.save!
+      @collection2.save!
     end
 
     describe 'member_of' do
       subject { @collection.member_of }
       it 'finds all nodes that aggregate the object with hasMember' do
-        expect(subject).to include(@collection1, @collection2)
+        expect(subject.to_a).to include(@collection1, @collection2)
         expect(subject.count).to eq 2
       end
     end
@@ -755,9 +571,6 @@ describe Hydra::PCDM::Collection do
         expect(subject.count).to eq 2
       end
     end
-    def build_proxy(container:)
-      instance_double(ActiveFedora::Aggregation::Proxy, container: container)
-    end
   end
 
   describe '.indexer' do
@@ -803,16 +616,20 @@ describe Hydra::PCDM::Collection do
 
   describe 'make sure deprecated methods still work' do
     it 'deprecated methods should pass' do
-      expect(collection1.child_collections = [collection2]).to eq [collection2]
-      expect(collection1.child_collections << collection3).to eq [collection2, collection3]
-      expect(collection1.child_collections += [collection4]).to eq [collection2, collection3, collection4]
-      expect(collection1.child_objects = [object1]).to eq [object1]
-      expect(collection1.child_objects << object2).to eq [object1, object2]
-      expect(collection1.child_objects += [object3]).to eq [object1, object2, object3]
+      expect(collection1.ordered_members = [collection2]).to eq [collection2]
+      expect(collection1.ordered_members << collection3).to eq [collection2, collection3]
+      expect(collection1.ordered_members += [collection4]).to eq [collection2, collection3, collection4]
+      expect(collection1.ordered_members << object1).to eq [collection2, collection3, collection4, object1]
+      expect(collection1.ordered_members << object2).to eq [collection2, collection3, collection4, object1, object2]
+      expect(collection1.ordered_members += [object3]).to eq [collection2, collection3, collection4, object1, object2, object3]
       collection1.save # required until issue AF-Agg-75 is fixed
       expect(collection2.parent_collections).to eq [collection1]
       expect(collection2.parents).to eq [collection1]
       expect(collection2.parent_collection_ids).to eq [collection1.id]
+      expect(collection1.child_objects).to eq [object1, object2, object3]
+      expect(collection1.child_object_ids).to eq [object1.id, object2.id, object3.id]
+      expect(collection1.child_collections).to eq [collection2, collection3, collection4]
+      expect(collection1.child_collection_ids).to eq [collection2.id, collection3.id, collection4.id]
     end
   end
 end