hydra-works 0.1.0 → 0.2.0

data/lib/hydra/works/services/generic_file/full_text_extraction_service.rb

@@ -0,0 +1,57 @@
+module Hydra::Works
+  # Extract the full text from the content using Solr's extract handler
+  class FullTextExtractionService
+    def self.run(generic_file)
+      new(generic_file).extract
+    end
+
+    delegate :original_file, :id, to: :@generic_file
+
+    def initialize(generic_file)
+      @generic_file = generic_file
+    end
+
+    ##
+    # Extract full text from the content using Solr's extract handler.
+    # This will extract text from the file uploaded to generic_file.
+    # The file uploaded to @generic_file can be accessed via :original_file.
+    #
+    # @return [String] The extracted text
+    def extract
+      JSON.parse(fetch)[''].rstrip
+    rescue Hydra::Works::FullTextExtractionError => e
+      raise e
+    rescue => e
+      raise Hydra::Works::FullTextExtractionError.new, "Error extracting content from #{id}: #{e.inspect}"
+    end
+
+    # send the request to the extract service and return the response if it was successful.
+    # TODO: this pulls the whole file into memory. We should stream it from Fedora instead
+    # @return [String] the result of calling the extract service
+    def fetch
+      req = Net::HTTP.new(uri.host, uri.port)
+      resp = req.post(uri.to_s, original_file.content, request_headers)
+      raise Hydra::Works::FullTextExtractionError.new, "Solr Extract service was unsuccessful. '#{uri}' returned code #{resp.code} for #{id}\n#{resp.body}" unless resp.code == '200'
+      original_file.content.rewind if original_file.content.respond_to?(:rewind)
+
+      resp.body
+    end
+
+    # @return [Hash] the request headers to send to the Solr extract service
+    def request_headers
+      { Faraday::Request::UrlEncoded::CONTENT_TYPE => "#{original_file.mime_type};charset=utf-8",
+        Faraday::Adapter::CONTENT_LENGTH => original_file.size.to_s }
+    end
+
+    # @returns [URI] path to the extract service
+    def uri
+      @uri ||= URI("#{connection_url}/update/extract?extractOnly=true&wt=json&extractFormat=text")
+    end
+
+    private
+
+      def connection_url
+        ActiveFedora.solr_config[:url]
+      end
+  end
+end

data/lib/hydra/works/services/generic_file/generate_thumbnail.rb

@@ -0,0 +1,13 @@
+module Hydra::Works
+  class GenerateThumbnail
+    def self.call(object, content: :original_file)
+      fail ArgumentError, "object has no content at #{content} from which to generate a thumbnail" if object.send(content).nil?
+
+      # Always replace the thumbnail with whatever is from the original file
+      object.build_thumbnail if object.thumbnail.nil?
+
+      object.create_derivatives
+      object
+    end
+  end
+end

data/lib/hydra/works/services/generic_file/persist_derivative.rb

@@ -2,21 +2,19 @@ require 'hydra/derivatives'
 
 module Hydra::Works
   class PersistDerivative < Hydra::Derivatives::PersistOutputFileService
-
     ##
     # Persists a derivative to a GenericFile
-    # This Service conforms to the signature of `Hydra::Derivatives::PersistOutputFileService`.  
+    # This Service conforms to the signature of `Hydra::Derivatives::PersistOutputFileService`.
     # The purpose of this Service is for use as an alternative to the default Hydra::Derivatives::PersistOutputFileService.  It's necessary because the default behavior in Hydra::Derivatives assumes that you're using LDP Basic Containment. Hydra::Works::GenericFiles use IndirectContainment.  This Service handles that case.
     # This service will always update existing and does not do versioning of persisted files.
-    # 
+    #
     # @param [Hydra::Works::GenericFile::Base] object the file will be added to
-    # @param [#read or String] file the derivative filestream optionally responds to :mime_type
+    # @param [Hydra::Derivatives::IoDecorator] file the derivative filestream
     # @param [String] extract file type symbol (e.g. :thumbnail) from Hydra::Derivatives created destination_name
 
     def self.call(object, file, destination_name)
       type = destination_name.gsub(/^original_file_/, '').to_sym
       Hydra::Works::AddFileToGenericFile.call(object, file, type, update_existing: true, versioning: false)
     end
-
   end
 end

data/lib/hydra/works/services/generic_file/{upload_file.rb → upload_file_to_generic_file.rb}

@@ -1,6 +1,5 @@
 module Hydra::Works
   class UploadFileToGenericFile
-
     # Sets a file as the primary file (original_file) of the generic_file
     # @param [Hydra::PCDM::GenericFile::Base] generic_file the file will be added to
     # @param [IO,File,Rack::Multipart::UploadedFile, #read] object that will be the contents. If file responds to :mime_type or :original_name, those will be called to provide technical metadata.
@@ -8,7 +7,7 @@ module Hydra::Works
     # @param [Boolean] update_existing whether to update an existing file if there is one. When set to true, performs a create_or_update. When set to false, always creates a new file within generic_file.files.
     # @param [Boolean] versioning whether to create new version entries (only applicable if +type+ corresponds to a versionable file)
 
-  def self.call(generic_file, file, additional_services: [], update_existing: true, versioning: true)
+    def self.call(generic_file, file, additional_services: [], update_existing: true, versioning: true)
       Hydra::Works::AddFileToGenericFile.call(generic_file, file, :original_file, update_existing: update_existing, versioning: versioning)
 
       # Call any additional services
@@ -19,6 +18,5 @@ module Hydra::Works
       generic_file.save
       generic_file
     end
-
   end
 end

data/lib/hydra/works/version.rb

@@ -1,5 +1,5 @@
 module Hydra
   module Works
-    VERSION = "0.1.0"
+    VERSION = '0.2.0'
   end
 end

data/lib/hydra/works/vocab/works_terms.rb

@@ -1,12 +1,12 @@
 require 'rdf'
-module WorksVocabularies
-  class WorksTerms < RDF::Vocabulary("http://projecthydra.org/works/models#")
-
-    # Class definitions
-    term :Collection
-    term :GenericWork
-    term :GenericFile
-    term :File
-
+module Hydra::Works
+  module Vocab
+    class WorksTerms < RDF::Vocabulary('http://projecthydra.org/works/models#')
+      # Class definitions
+      term :Collection
+      term :GenericWork
+      term :GenericFile
+      term :File
+    end
   end
 end

data/lib/tasks/hydra-works_tasks.rake

@@ -0,0 +1,80 @@
+require 'net/http'
+
+namespace :hydra_works do
+  namespace :jetty do
+
+    FULLTEXT_JARS = %w(
+        org/apache/james/apache-mime4j-core/0.7.2/apache-mime4j-core-0.7.2.jar
+        org/apache/james/apache-mime4j-dom/0.7.2/apache-mime4j-dom-0.7.2.jar
+        org/apache/solr/solr-cell/4.0.0/solr-cell-4.0.0.jar
+        org/bouncycastle/bcmail-jdk15/1.45/bcmail-jdk15-1.45.jar
+        org/bouncycastle/bcprov-jdk15/1.45/bcprov-jdk15-1.45.jar
+        de/l3s/boilerpipe/boilerpipe/1.1.0/boilerpipe-1.1.0.jar
+        org/apache/commons/commons-compress/1.4.1/commons-compress-1.4.1.jar
+        dom4j/dom4j/1.6.1/dom4j-1.6.1.jar
+        org/apache/pdfbox/fontbox/1.7.0/fontbox-1.7.0.jar
+        com/ibm/icu/icu4j/49.1/icu4j-49.1.jar
+        com/googlecode/mp4parser/isoparser/1.0-RC-1/isoparser-1.0-RC-1.jar
+        jdom/jdom/1.0/jdom-1.0.jar
+        org/apache/pdfbox/jempbox/1.7.0/jempbox-1.7.0.jar
+        com/googlecode/juniversalchardet/juniversalchardet/1.0.3/juniversalchardet-1.0.3.jar
+        com/drewnoakes/metadata-extractor/2.4.0-beta-1/metadata-extractor-2.4.0-beta-1.jar
+        edu/ucar/netcdf/4.2-min/netcdf-4.2-min.jar
+        org/apache/pdfbox/pdfbox/1.7.0/pdfbox-1.7.0.jar
+        org/apache/poi/poi/3.8/poi-3.8.jar
+        org/apache/poi/poi-ooxml/3.8/poi-ooxml-3.8.jar
+        org/apache/poi/poi-ooxml-schemas/3.8/poi-ooxml-schemas-3.8.jar
+        org/apache/poi/poi-scratchpad/3.8/poi-scratchpad-3.8.jar
+        rome/rome/0.9/rome-0.9.jar
+        org/ccil/cowan/tagsoup/tagsoup/1.2.1/tagsoup-1.2.1.jar
+        org/apache/tika/tika-core/1.2/tika-core-1.2.jar
+        org/apache/tika/tika-parsers/1.2/tika-parsers-1.2.jar
+        org/gagravarr/vorbis-java-core/0.1/vorbis-java-core-0.1.jar
+        org/gagravarr/vorbis-java-tika/0.1/vorbis-java-tika-0.1.jar
+        xerces/xercesImpl/2.9.1/xercesImpl-2.9.1.jar
+        org/apache/xmlbeans/xmlbeans/2.3.0/xmlbeans-2.3.0.jar
+        org/tukaani/xz/1.0/xz-1.0.jar
+        org/aspectj/aspectjrt/1.8.5/aspectjrt-1.8.5.jar
+      )
+
+    desc 'Configure jetty with full-text indexing'
+    task config: :download_jars do
+      Rake::Task['jetty:config'].invoke
+    end
+
+    desc 'Download Solr full-text extraction jars'
+    task :download_jars do
+      puts "Copying new solrconfig.xml"
+      source = File.join(File.dirname(__FILE__), '..', '..', 'config', 'solrconfig.xml')
+      dest = File.join('solr_conf','conf')
+      FileUtils.mkdir_p(dest) unless File.directory?(dest)
+      cp source, dest
+      puts "Downloading full-text jars from maven.org ..."
+      fulltext_dir = 'jetty/solr/lib/contrib/extraction/lib'
+      FileUtils.mkdir_p(fulltext_dir) unless File.directory?(fulltext_dir)
+      Dir.chdir(fulltext_dir) do
+        FULLTEXT_JARS.each do |jar|
+          destination = jar.split('/').last
+          download_from_maven(jar, destination) unless File.exists?(destination)
+        end
+      end
+    end
+  end
+end
+
+def download_from_maven url, dst
+  full_url = '/remotecontent?filepath=' + url
+  file = File.open(dst, "wb")
+  endpoint = Net::HTTP.new('search.maven.org', 443)
+  endpoint.use_ssl = true
+  endpoint.start do |http|
+    puts "Fetching #{full_url}"
+    begin
+      http.request_get(full_url) do |resp|
+        resp.read_body { |segment| file.write(segment) }
+      end
+    ensure
+      file.close
+    end
+  end
+end

data/lib/tasks/jetty.rake

@@ -0,0 +1,15 @@
+namespace :jetty do
+  desc "Copies the default Solr & Fedora configs into the bundled Hydra Testing Server"
+  task :config do
+    Rake::Task['hydra_works:jetty:download_jars'].invoke
+    Rake::Task["jetty:config_solr"].invoke
+  end
+
+  desc "Copies the contents of solr_conf into the Solr development-core and test-core of Testing Server"
+  task :config_solr do
+    FileList['solr_conf/conf/*'].each do |f|
+      cp("#{f}", 'jetty/solr/development-core/conf/', verbose: true)
+      cp("#{f}", 'jetty/solr/test-core/conf/', verbose: true)
+    end
+  end
+end

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

@@ -1,51 +1,52 @@
 require 'spec_helper'
 
 describe Hydra::Works::Collection do
+  subject { described_class.new }
 
-  subject { Hydra::Works::Collection.new }
-
-  let(:collection1) { Hydra::Works::Collection.new }
-  let(:collection2) { Hydra::Works::Collection.new }
-  let(:collection3) { Hydra::Works::Collection.new }
+  let(:collection1) { described_class.new }
+  let(:collection2) { described_class.new }
+  let(:collection3) { described_class.new }
+  let(:collection4) { described_class.new }
 
   let(:generic_work1) { Hydra::Works::GenericWork::Base.new }
   let(:generic_work2) { Hydra::Works::GenericWork::Base.new }
   let(:generic_work3) { Hydra::Works::GenericWork::Base.new }
+  let(:generic_work4) { Hydra::Works::GenericWork::Base.new }
 
-  describe '#child_collections' do
-    it 'should return empty array when only generic_works are aggregated' do
-      subject.child_generic_works << generic_work1
-      subject.child_generic_works << generic_work2
-      expect(subject.child_collections ).to eq []
+  describe '#collections' do
+    it 'returns empty array when only generic_works are aggregated' do
+      subject.generic_works << generic_work1
+      subject.generic_works << generic_work2
+      expect(subject.collections).to eq []
     end
 
-    context 'with other collections & generic_works' do 
-      before do 
-        subject.child_collections << collection1
-        subject.child_collections << collection2
-        subject.child_generic_works << generic_work1
-        subject.child_generic_works << generic_work2
+    context 'with other collections & generic_works' do
+      before do
+        subject.collections << collection1
+        subject.collections << collection2
+        subject.generic_works << generic_work1
+        subject.generic_works << generic_work2
       end
 
-      it 'should only return collections' do
-        expect(subject.child_collections ).to eq [collection1,collection2]
+      it 'returns only collections' do
+        expect(subject.collections).to eq [collection1, collection2]
       end
-    end  
+    end
   end
 
-  describe '#child_collections <<' do
+  describe '#collections <<' do
     context 'with acceptable collections' do
       context 'with collections and generic_works' do
         before do
-          subject.child_collections << collection1
-          subject.child_collections << collection2
-          subject.child_generic_works << generic_work1
-          subject.child_generic_works << generic_work2
+          subject.collections << collection1
+          subject.collections << collection2
+          subject.generic_works << generic_work1
+          subject.generic_works << generic_work2
         end
 
-        it 'should add an generic_work to collection with collections and generic_works' do
-          subject.child_collections << collection3
-          expect( subject.child_collections ).to eq [collection1,collection2,collection3]
+        it 'adds an generic_work to collection with collections and generic_works' do
+          subject.collections << collection3
+          expect(subject.collections).to eq [collection1, collection2, collection3]
         end
       end
 
@@ -58,14 +59,14 @@ describe Hydra::Works::Collection do
         after { Object.send(:remove_const, :Kollection) }
         let(:kollection1) { Kollection.new }
 
-        it 'should accept implementing collection as a child' do
-          subject.child_collections << kollection1
-          expect( subject.child_collections ).to eq [kollection1]
+        it 'accepts implementing collection as a child' do
+          subject.collections << kollection1
+          expect(subject.collections).to eq [kollection1]
         end
 
-        it 'should accept implementing collection as a parent' do
-          subject.child_collections << collection1
-          expect( subject.child_collections ).to eq [collection1]
+        it 'accepts implementing collection as a parent' do
+          subject.collections << collection1
+          expect(subject.collections).to eq [collection1]
         end
       end
 
@@ -77,137 +78,135 @@ describe Hydra::Works::Collection do
         after { Object.send(:remove_const, :Cullection) }
         let(:cullection1) { Cullection.new }
 
-        it 'should accept extending collection as a child' do
-          subject.child_collections << cullection1
-          expect( subject.child_collections ).to eq [cullection1]
+        it 'accepts extending collection as a child' do
+          subject.collections << cullection1
+          expect(subject.collections).to eq [cullection1]
         end
 
-        it 'should accept extending collection as a parent' do
-          subject.child_collections << collection1
-          expect( subject.child_collections ).to eq [collection1]
+        it 'accepts extending collection as a parent' do
+          subject.collections << collection1
+          expect(subject.collections).to eq [collection1]
         end
       end
     end
 
     context 'with unacceptable inputs' do
       before(:all) do
-        @works_collection101  = Hydra::Works::Collection.new
+        @works_collection101  = described_class.new
         @generic_work101      = Hydra::Works::GenericWork::Base.new
         @generic_file101      = Hydra::Works::GenericFile::Base.new
         @pcdm_collection101   = Hydra::PCDM::Collection.new
         @pcdm_object101       = Hydra::PCDM::Object.new
         @pcdm_file101         = Hydra::PCDM::File.new
-        @non_PCDM_object      = "I'm not a PCDM object"
+        @non_pcdm_object      = "I'm not a PCDM object"
         @af_base_object       = ActiveFedora::Base.new
       end
 
       context 'that are unacceptable child collections' do
-
         let(:error_type1)    { ArgumentError }
         let(:error_message1) { /Hydra::Works::Generic(Work|File)::Base with ID:  was expected to works_collection\?, but it was false/ }
         let(:error_type2)    { NoMethodError }
         let(:error_message2) { /undefined method `works_collection\?' for .*/ }
 
-        it 'should NOT aggregate Hydra::Works::GenericWork in collections aggregation' do
-          expect{ subject.child_collections << @generic_work101 }.to raise_error(error_type1,error_message1)
+        it 'does not aggregate Hydra::Works::GenericWork in collections aggregation' do
+          expect { subject.collections << @generic_work101 }.to raise_error(error_type1, error_message1)
         end
 
-        it 'should NOT aggregate Hydra::Works::GenericFile in collections aggregation' do
-          expect{ subject.child_collections << @generic_file101 }.to raise_error(error_type1,error_message1)
+        it 'does not aggregate Hydra::Works::GenericFile in collections aggregation' do
+          expect { subject.collections << @generic_file101 }.to raise_error(error_type1, error_message1)
         end
 
-        it 'should NOT aggregate Hydra::PCDM::Collections in collections aggregation' do
-          expect{ subject.child_collections << @pcdm_collection101 }.to raise_error(error_type2,error_message2)
+        it 'does not aggregate Hydra::PCDM::Collections in collections aggregation' do
+          expect { subject.collections << @pcdm_collection101 }.to raise_error(error_type2, error_message2)
         end
 
-        it 'should NOT aggregate Hydra::PCDM::Objects in collections aggregation' do
-          expect{ subject.child_collections << @pcdm_object101 }.to raise_error(error_type2,error_message2)
+        it 'does not aggregate Hydra::PCDM::Objects in collections aggregation' do
+          expect { subject.collections << @pcdm_object101 }.to raise_error(error_type2, error_message2)
         end
 
-        it 'should NOT aggregate Hydra::PCDM::Files in collections aggregation' do
-          expect{ subject.child_collections << @pcdm_file101 }.to raise_error(error_type2,error_message2)
+        it 'does not aggregate Hydra::PCDM::Files in collections aggregation' do
+          expect { subject.collections << @pcdm_file101 }.to raise_error(error_type2, error_message2)
         end
 
-        it 'should NOT aggregate non-PCDM objects in collections aggregation' do
-          expect{ subject.child_collections << @non_PCDM_object }.to raise_error(error_type2,error_message2)
+        it 'does not aggregate non-PCDM objects in collections aggregation' do
+          expect { subject.collections << @non_pcdm_object }.to raise_error(error_type2, error_message2)
         end
 
-        it 'should NOT aggregate AF::Base objects in collections aggregation' do
-          expect{ subject.child_collections << @af_base_object }.to raise_error(error_type2,error_message2)
+        it 'does not aggregate AF::Base objects in collections aggregation' do
+          expect { subject.collections << @af_base_object }.to raise_error(error_type2, error_message2)
         end
       end
     end
   end
 
-  describe 'child_collections.delete' do
+  describe 'collections.delete' do
     context 'when multiple collections' do
       before do
-        subject.child_collections << collection1
-        subject.child_collections << collection2
-        subject.child_generic_works << generic_work2
-        subject.child_collections << collection3
-        subject.child_generic_works << generic_work1
-        expect( subject.child_collections ).to eq [collection1,collection2,collection3]
-      end
-      
-      it 'should remove first collection' do
-        expect( subject.child_collections.delete collection1 ).to eq [collection1]
-        expect( subject.child_collections ).to eq [collection2,collection3]
-        expect( subject.child_generic_works ).to eq [generic_work2,generic_work1]    
-      end
-        
-      it 'should remove last collection' do
-        expect( subject.child_collections.delete collection3 ).to eq [collection3]
-        expect( subject.child_collections ).to eq [collection1,collection2]
-        expect( subject.child_generic_works). to eq [generic_work2,generic_work1]      
-      end
-   
-      it 'should remove middle collection' do
-        expect( subject.child_collections.delete collection2 ).to eq [collection2]
-        expect( subject.child_collections ).to eq [collection1,collection3]
-        expect( subject.child_generic_works). to eq [generic_work2,generic_work1]    
-      end
-    end 
-  end   
-
-  describe '#child_generic_works' do
-    it 'should return empty array when only collections are aggregated' do
-      subject.child_collections << collection1
-      subject.child_collections << collection2
-      expect(subject.child_generic_works). to eq []
+        subject.collections << collection1
+        subject.collections << collection2
+        subject.generic_works << generic_work2
+        subject.collections << collection3
+        subject.generic_works << generic_work1
+        expect(subject.collections).to eq [collection1, collection2, collection3]
+      end
+
+      it 'removes first collection' do
+        expect(subject.collections.delete collection1).to eq [collection1]
+        expect(subject.collections).to eq [collection2, collection3]
+        expect(subject.generic_works).to eq [generic_work2, generic_work1]
+      end
+
+      it 'removes last collection' do
+        expect(subject.collections.delete collection3).to eq [collection3]
+        expect(subject.collections).to eq [collection1, collection2]
+        expect(subject.generic_works). to eq [generic_work2, generic_work1]
+      end
+
+      it 'removes middle collection' do
+        expect(subject.collections.delete collection2).to eq [collection2]
+        expect(subject.collections).to eq [collection1, collection3]
+        expect(subject.generic_works). to eq [generic_work2, generic_work1]
+      end
+    end
+  end
+
+  describe '#generic_works' do
+    it 'returns empty array when only collections are aggregated' do
+      subject.collections << collection1
+      subject.collections << collection2
+      expect(subject.generic_works). to eq []
     end
 
     context 'with collections and generic works' do
-      before do 
-        subject.child_collections << collection1
-        subject.child_collections << collection2
-        subject.child_generic_works << generic_work1
-        subject.child_generic_works << generic_work2
+      before do
+        subject.collections << collection1
+        subject.collections << collection2
+        subject.generic_works << generic_work1
+        subject.generic_works << generic_work2
       end
 
-      it 'should only return generic works' do
-        expect(subject.child_generic_works). to eq [generic_work1,generic_work2]     
+      it 'returns only generic works' do
+        expect(subject.generic_works). to eq [generic_work1, generic_work2]
       end
     end
-  end 
+  end
 
-  describe '#child_generic_works <<' do
-    
+  describe '#generic_works <<' do
     context 'with acceptable generic_works' do
       context 'with collections and generic_works' do
         before do
-          subject.child_collections << collection1
-          subject.child_collections << collection2
-          subject.child_generic_works << generic_work1
-          subject.child_generic_works << generic_work2
+          subject.collections << collection1
+          subject.collections << collection2
+          subject.generic_works << generic_work1
+          subject.generic_works << generic_work2
         end
 
-        it 'should add generic_work to collection with collections and generic_works' do 
-          subject.child_generic_works << generic_work3
-          expect( subject.child_generic_works  ).to eq [generic_work1,generic_work2,generic_work3]
+        it 'adds generic_work to collection with collections and generic_works' do
+          subject.generic_works << generic_work3
+          expect(subject.generic_works).to eq [generic_work1, generic_work2, generic_work3]
         end
       end
-      
+
       describe 'aggregates generic_works that implement Hydra::Works' do
         before do
           class DummyIncWork < ActiveFedora::Base
@@ -216,12 +215,12 @@ describe Hydra::Works::Collection do
         end
         after { Object.send(:remove_const, :DummyIncWork) }
         let(:iwork1) { DummyIncWork.new }
-        
-        it 'should accept implementing generic_work as a child' do
-          subject.child_generic_works << iwork1
-          expect( subject.child_generic_works  ).to eq [iwork1]
+
+        it 'accepts implementing generic_work as a child' do
+          subject.generic_works << iwork1
+          expect(subject.generic_works).to eq [iwork1]
         end
-      end 
+      end
 
       describe 'aggregates generic_works that extend Hydra::Works' do
         before do
@@ -231,93 +230,92 @@ describe Hydra::Works::Collection do
         after { Object.send(:remove_const, :DummyExtWork) }
         let(:ework1) { DummyExtWork.new }
 
-        it 'should accept extending generic_work as a child' do
-          subject.child_generic_works << ework1
-          expect( subject.child_generic_works  ).to eq [ework1]
+        it 'accepts extending generic_work as a child' do
+          subject.generic_works << ework1
+          expect(subject.generic_works).to eq [ework1]
         end
       end
     end
 
     context 'with unacceptable inputs' do
       before(:all) do
-        @works_collection101  = Hydra::Works::Collection.new
-        @works_collection102  = Hydra::Works::Collection.new
+        @works_collection101  = described_class.new
+        @works_collection102  = described_class.new
         @generic_file101      = Hydra::Works::GenericFile::Base.new
         @pcdm_collection101   = Hydra::PCDM::Collection.new
         @pcdm_object101       = Hydra::PCDM::Object.new
         @pcdm_file101         = Hydra::PCDM::File.new
-        @non_PCDM_object      = "I'm not a PCDM object"
+        @non_pcdm_object      = "I'm not a PCDM object"
         @af_base_object       = ActiveFedora::Base.new
       end
 
       context 'that are unacceptable child generic works' do
-
         let(:error_type1)    { ArgumentError }
         let(:error_message1) { /Hydra::Works::(GenericFile::Base|Collection) with ID:  was expected to works_generic_work\?, but it was false/ }
         let(:error_type2)    { NoMethodError }
         let(:error_message2) { /undefined method `works_generic_work\?' for .*/ }
 
-        it 'should NOT aggregate Hydra::Works::Collection in generic works aggregation' do
-          expect{ subject.child_generic_works << @works_collection101 }.to raise_error(error_type1,error_message1)
+        it 'does not aggregate Hydra::Works::Collection in generic works aggregation' do
+          expect { subject.generic_works << @works_collection101 }.to raise_error(error_type1, error_message1)
         end
 
-        it 'should NOT aggregate Hydra::Works::GenericFile in generic works aggregation' do
-          expect{ subject.child_generic_works << @generic_file101 }.to raise_error(error_type1,error_message1)
+        it 'does not aggregate Hydra::Works::GenericFile in generic works aggregation' do
+          expect { subject.generic_works << @generic_file101 }.to raise_error(error_type1, error_message1)
         end
 
-        it 'should NOT aggregate Hydra::PCDM::Collections in generic works aggregation' do
-          expect{ subject.child_generic_works << @pcdm_collection101 }.to raise_error(error_type2,error_message2)
+        it 'does not aggregate Hydra::PCDM::Collections in generic works aggregation' do
+          expect { subject.generic_works << @pcdm_collection101 }.to raise_error(error_type2, error_message2)
         end
 
-        it 'should NOT aggregate Hydra::PCDM::Objects in generic works aggregation' do
-          expect{ subject.child_generic_works << @pcdm_object101 }.to raise_error(error_type2,error_message2)
+        it 'does not aggregate Hydra::PCDM::Objects in generic works aggregation' do
+          expect { subject.generic_works << @pcdm_object101 }.to raise_error(error_type2, error_message2)
         end
 
-        it 'should NOT aggregate Hydra::PCDM::Files in generic works aggregation' do
-          expect{ subject.child_generic_works << @pcdm_file101 }.to raise_error(error_type2,error_message2)
+        it 'does not aggregate Hydra::PCDM::Files in generic works aggregation' do
+          expect { subject.generic_works << @pcdm_file101 }.to raise_error(error_type2, error_message2)
         end
 
-        it 'should NOT aggregate non-PCDM objects in generic works aggregation' do
-          expect{ subject.child_generic_works << @non_PCDM_object }.to raise_error(error_type2,error_message2)
+        it 'does not aggregate non-PCDM objects in generic works aggregation' do
+          expect { subject.generic_works << @non_pcdm_object }.to raise_error(error_type2, error_message2)
         end
 
-        it 'should NOT aggregate AF::Base objects in generic works aggregation' do
-          expect{ subject.child_generic_works << @af_base_object }.to raise_error(error_type2,error_message2)
+        it 'does not aggregate AF::Base objects in generic works aggregation' do
+          expect { subject.generic_works << @af_base_object }.to raise_error(error_type2, error_message2)
         end
       end
     end
   end
 
-  describe '#child_generic_works.delete' do
+  describe '#generic_works.delete' do
     context 'when multiple generic works' do
       before do
-        subject.child_generic_works << generic_work1
-        subject.child_generic_works << generic_work2
-        subject.child_collections << collection2
-        subject.child_generic_works << generic_work3
-        subject.child_collections << collection1
-        expect( subject.child_generic_works). to eq [generic_work1,generic_work2,generic_work3]
-      end
-      
-      it 'should remove first generic work' do
-        expect( subject.child_generic_works.delete generic_work1 ).to eq [generic_work1]
-        expect( subject.child_generic_works). to eq [generic_work2,generic_work3]
-        expect( subject.child_collections ).to eq [collection2,collection1]
-      end
-        
-      it 'should remove last generic work' do
-        expect( subject.child_generic_works.delete generic_work3 ).to eq [generic_work3]
-        expect( subject.child_generic_works). to eq [generic_work1,generic_work2]
-        expect( subject.child_collections ).to eq [collection2,collection1]
-      end
-   
-      it 'should remove middle generic work' do
-        expect( subject.child_generic_works.delete generic_work2 ).to eq [generic_work2]
-        expect( subject.child_generic_works). to eq [generic_work1,generic_work3]
-        expect( subject.child_collections ).to eq [collection2,collection1]
-      end
-    end 
-  end   
+        subject.generic_works << generic_work1
+        subject.generic_works << generic_work2
+        subject.collections << collection2
+        subject.generic_works << generic_work3
+        subject.collections << collection1
+        expect(subject.generic_works). to eq [generic_work1, generic_work2, generic_work3]
+      end
+
+      it 'removes first generic work' do
+        expect(subject.generic_works.delete generic_work1).to eq [generic_work1]
+        expect(subject.generic_works). to eq [generic_work2, generic_work3]
+        expect(subject.collections).to eq [collection2, collection1]
+      end
+
+      it 'removes last generic work' do
+        expect(subject.generic_works.delete generic_work3).to eq [generic_work3]
+        expect(subject.generic_works). to eq [generic_work1, generic_work2]
+        expect(subject.collections).to eq [collection2, collection1]
+      end
+
+      it 'removes middle generic work' do
+        expect(subject.generic_works.delete generic_work2).to eq [generic_work2]
+        expect(subject.generic_works). to eq [generic_work1, generic_work3]
+        expect(subject.collections).to eq [collection2, collection1]
+      end
+    end
+  end
 
   describe '#related_objects' do
     let(:generic_file1) { Hydra::Works::GenericFile::Base.new }
@@ -326,69 +324,68 @@ describe Hydra::Works::Collection do
 
     context 'with collections and generic works' do
       before do
-        subject.child_collections << collection1
-        subject.child_collections << collection2
-        subject.child_generic_works << generic_work1
+        subject.collections << collection1
+        subject.collections << collection2
+        subject.generic_works << generic_work1
       end
-        
-      it 'should return empty array when only collections and generic works are aggregated' do
-        expect(subject.related_objects ).to eq []
+
+      it 'returns empty array when only collections and generic works are aggregated' do
+        expect(subject.related_objects).to eq []
       end
-      
-      it 'should only return related objects' do
+
+      it 'returns only related objects' do
         subject.related_objects << object2
-        expect(subject.related_objects ).to eq [object2]
+        expect(subject.related_objects).to eq [object2]
       end
-  
-      it 'should return related objects of various types' do
+
+      it 'returns related objects of various types' do
         subject.related_objects << generic_work2
         subject.related_objects << generic_file1
         subject.related_objects << object1
         subject.save
         subject.reload
-        expect( subject.related_objects.include? object1 ).to be true
-        expect( subject.related_objects.include? generic_work2 ).to be true
-        expect( subject.related_objects.include? generic_file1 ).to be true
-        expect( subject.related_objects.size ).to eq 3
+        expect(subject.related_objects.include? object1).to be true
+        expect(subject.related_objects.include? generic_work2).to be true
+        expect(subject.related_objects.include? generic_file1).to be true
+        expect(subject.related_objects.size).to eq 3
       end
     end
   end
 
   describe '#related_objects <<' do
-
     context 'with acceptable related objects' do
       let(:object1) { Hydra::PCDM::Object.new }
       let(:object2) { Hydra::PCDM::Object.new }
       let(:generic_file1) { Hydra::Works::GenericFile::Base.new }
 
-      it 'should add various types of related objects to collection' do
+      it 'adds various types of related objects to collection' do
         subject.related_objects << generic_work1
         subject.related_objects << generic_file1
         subject.related_objects << object1
         subject.save
         subject.reload
-        expect( subject.related_objects.include? generic_work1 ).to be true
-        expect( subject.related_objects.include? generic_file1 ).to be true
-        expect( subject.related_objects.include? object1 ).to be true
-        expect( subject.related_objects.size ).to eq 3
+        expect(subject.related_objects.include? generic_work1).to be true
+        expect(subject.related_objects.include? generic_file1).to be true
+        expect(subject.related_objects.include? object1).to be true
+        expect(subject.related_objects.size).to eq 3
       end
 
       context 'with collections and generic_works' do
         before do
-          subject.child_collections << collection1
-          subject.child_collections << collection2
-          subject.child_generic_works << generic_work1
-          subject.child_generic_works << generic_work2
+          subject.collections << collection1
+          subject.collections << collection2
+          subject.generic_works << generic_work1
+          subject.generic_works << generic_work2
           subject.related_objects << object1
         end
 
-        it 'should add a related object to collection with collections and generic_works' do
+        it 'adds a related object to collection with collections and generic_works' do
           subject.related_objects << object2
           subject.save
           subject.reload
-          expect( subject.related_objects.include? object1 ).to be true
-          expect( subject.related_objects.include? object2 ).to be true
-          expect( subject.related_objects.size ).to eq 2
+          expect(subject.related_objects.include? object1).to be true
+          expect(subject.related_objects.include? object2).to be true
+          expect(subject.related_objects.size).to eq 2
         end
       end
     end
@@ -399,24 +396,24 @@ describe Hydra::Works::Collection do
       let(:non_PCDM_object)  { "I'm not a PCDM object" }
       let(:af_base_object)   { ActiveFedora::Base.new }
 
-      it 'should NOT aggregate Hydra::Works::Collection in related objects aggregation' do
-        expect{ subject.related_objects << collection1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /Hydra::Works::Collection:.*> is not a PCDM object./)
+      it 'does not aggregate Hydra::Works::Collection in related objects aggregation' do
+        expect { subject.related_objects << collection1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /Hydra::Works::Collection:.*> is not a PCDM object./)
       end
 
-      it 'should NOT aggregate Hydra::PCDM::Collections in related objects aggregation' do
-        expect{ subject.related_objects << pcdm_collection1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /Hydra::PCDM::Collection:.* is not a PCDM object./)
+      it 'does not aggregate Hydra::PCDM::Collections in related objects aggregation' do
+        expect { subject.related_objects << pcdm_collection1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /Hydra::PCDM::Collection:.* is not a PCDM object./)
       end
 
-      it 'should NOT aggregate Hydra::PCDM::Files in related objects aggregation' do
-        expect{ subject.related_objects << pcdm_file1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* expected, got Hydra::PCDM::File.*/)
+      it 'does not aggregate Hydra::PCDM::Files in related objects aggregation' do
+        expect { subject.related_objects << pcdm_file1 }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* expected, got Hydra::PCDM::File.*/)
       end
 
-      it 'should NOT aggregate non-PCDM objects in related objects aggregation' do
-        expect{ subject.related_objects << non_PCDM_object }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* expected, got String.*/)
+      it 'does not aggregate non-PCDM objects in related objects aggregation' do
+        expect { subject.related_objects << non_PCDM_object }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* expected, got String.*/)
       end
 
-      it 'should NOT aggregate AF::Base objects in related objects aggregation' do
-        expect{ subject.related_objects << af_base_object }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* is not a PCDM object./)
+      it 'does not aggregate AF::Base objects in related objects aggregation' do
+        expect { subject.related_objects << af_base_object }.to raise_error(ActiveFedora::AssociationTypeMismatch, /ActiveFedora::Base.* is not a PCDM object./)
       end
     end
 
@@ -424,16 +421,16 @@ describe Hydra::Works::Collection do
       let(:object1) { Hydra::PCDM::Object.new }
       let(:object2) { Hydra::PCDM::Object.new }
 
-      it 'should NOT allow related objects to repeat' do
+      it 'does not allow related objects to repeat' do
         skip 'skipping this test because issue pcdm#92 needs to be addressed' do
-        subject.related_objects << object1
-        subject.related_objects << object2
-        subject.related_objects << object1
-        related_objects = subject.related_objects
-        expect( related_objects.include? object1 ).to be true
-        expect( related_objects.include? object2 ).to be true
-        expect( related_objects.size ).to eq 2
-      end
+          subject.related_objects << object1
+          subject.related_objects << object2
+          subject.related_objects << object1
+          related_objects = subject.related_objects
+          expect(related_objects.include? object1).to be true
+          expect(related_objects.include? object2).to be true
+          expect(related_objects.size).to eq 2
+        end
       end
     end
   end
@@ -449,55 +446,55 @@ describe Hydra::Works::Collection do
       before do
         subject.related_objects << related_object1
         subject.related_objects << related_work2
-        subject.child_collections << collection2
-        subject.child_generic_works << generic_work1
+        subject.collections << collection2
+        subject.generic_works << generic_work1
         subject.related_objects << related_file3
         subject.related_objects << related_object4
-        subject.child_collections << collection1
+        subject.collections << collection1
         subject.related_objects << related_work5
-        expect( subject.related_objects ).to eq [related_object1,related_work2,related_file3,related_object4,related_work5]
+        expect(subject.related_objects).to eq [related_object1, related_work2, related_file3, related_object4, related_work5]
       end
-        
-      it 'should remove first related object' do
-        expect( subject.related_objects.delete related_object1 ).to eq [related_object1]
-        expect( subject.related_objects ).to eq [related_work2,related_file3,related_object4,related_work5]
-        expect( subject.child_collections ).to eq [collection2,collection1]
-        expect( subject.child_generic_works). to eq [generic_work1]
+
+      it 'removes first related object' do
+        expect(subject.related_objects.delete related_object1).to eq [related_object1]
+        expect(subject.related_objects).to eq [related_work2, related_file3, related_object4, related_work5]
+        expect(subject.collections).to eq [collection2, collection1]
+        expect(subject.generic_works). to eq [generic_work1]
       end
 
-      it 'should remove last related object' do
-        expect( subject.related_objects.delete related_work5 ).to eq [related_work5]
-        expect( subject.related_objects ).to eq [related_object1,related_work2,related_file3,related_object4]
-        expect( subject.child_collections ).to eq [collection2,collection1]
-        expect( subject.child_generic_works). to eq [generic_work1]
+      it 'removes last related object' do
+        expect(subject.related_objects.delete related_work5).to eq [related_work5]
+        expect(subject.related_objects).to eq [related_object1, related_work2, related_file3, related_object4]
+        expect(subject.collections).to eq [collection2, collection1]
+        expect(subject.generic_works). to eq [generic_work1]
       end
-        
-      it 'should remove middle related object' do
-        expect( subject.related_objects.delete related_file3 ).to eq [related_file3]
-        expect( subject.related_objects ).to eq [related_object1,related_work2,related_object4,related_work5]
-        expect( subject.child_collections ).to eq [collection2,collection1]
-        expect( subject.child_generic_works). to eq [generic_work1]
+
+      it 'removes middle related object' do
+        expect(subject.related_objects.delete related_file3).to eq [related_file3]
+        expect(subject.related_objects).to eq [related_object1, related_work2, related_object4, related_work5]
+        expect(subject.collections).to eq [collection2, collection1]
+        expect(subject.generic_works). to eq [generic_work1]
       end
-    end 
-  end   
+    end
+  end
 
   describe '#collections=' do
-    it 'should aggregate collections' do
-      collection1.child_collections = [collection2, collection3]
-      expect(collection1.child_collections).to eq [collection2, collection3]
+    it 'aggregates collections' do
+      collection1.collections = [collection2, collection3]
+      expect(collection1.collections).to eq [collection2, collection3]
     end
   end
 
-  describe '#child_generic_works=' do
-    it 'should aggregate generic_works' do
-      collection1.child_generic_works = [generic_work1,generic_work2]
-      expect(collection1.child_generic_works).to eq [generic_work1,generic_work2]
+  describe '#generic_works=' do
+    it 'aggregates generic_works' do
+      collection1.generic_works = [generic_work1, generic_work2]
+      expect(collection1.generic_works).to eq [generic_work1, generic_work2]
     end
   end
 
   describe 'Related objects' do
     let(:object) { Hydra::PCDM::Object.new }
-    let(:collection) { Hydra::Works::Collection.new }
+    let(:collection) { described_class.new }
 
     before do
       collection.related_objects = [object]
@@ -508,17 +505,32 @@ describe Hydra::Works::Collection do
     end
   end
 
-  describe "should have parent collection accessors" do
+  describe 'should have parent collection accessors' do
     before do
-      collection1.child_collections << collection2
+      collection1.collections << collection2
       collection1.save
     end
 
-    it 'should have parents' do
-      expect(collection2.parents).to eq [collection1]
+    it 'has parents' do
+      expect(collection2.member_of).to eq [collection1]
+    end
+    it 'has a parent collection' do
+      expect(collection2.in_collections).to eq [collection1]
     end
-    it 'should have a parent collection' do
+  end
+
+  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_generic_works = [generic_work1]).to eq [generic_work1]
+      expect(collection1.child_generic_works << generic_work2).to eq [generic_work1, generic_work2]
+      expect(collection1.child_generic_works += [generic_work3]).to eq [generic_work1, generic_work2, generic_work3]
+      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]
     end
   end
 end