mods 2.4.0 → 3.0.0

data/spec/lib/physical_description_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe "Mods <physicalDescription> Element" do
+  it "extent child element" do
+    record = mods_record("<physicalDescription><extent>extent</extent></physicalDescription>")
+    expect(record.physical_description.extent.map(&:text)).to eq(["extent"])
+  end
+
+  context "note child element" do
+    subject(:note) do
+      mods_record(<<-XML).physical_description.note
+        <physicalDescription>
+          <form authority='aat'>Graphics</form>
+          <form>plain form</form>
+          <note displayLabel='Dimensions'>dimension text</note>
+          <note displayLabel='Condition'>condition text</note>
+        </physicalDescription>
+      XML
+    end
+    it "should understand note element" do
+      expect(note.map(&:text)).to eq(["dimension text", "condition text"])
+    end
+    it "should understand displayLabel attribute on note element" do
+      expect(note.displayLabel).to eq(["Dimensions", "Condition"])
+    end
+  end
+
+  context "form child element" do
+    subject(:physical_description) do
+      mods_record(<<-XML).physical_description
+        <physicalDescription>
+          <form authority='smd'>map</form>
+          <form type='material'>foo</form>
+          <extent>1 map ; 22 x 18 cm.</extent>
+        </physicalDescription>
+      XML
+    end
+
+    it "should understand form element" do
+      expect(physical_description.form.map(&:text)).to eq(["map", "foo"])
+    end
+    it "should understand authority attribute on form element" do
+      expect(physical_description.form.authority).to eq(["smd"])
+    end
+    it "should understand type attribute on form element" do
+      expect(physical_description.form.type_at).to eq(["material"])
+    end
+  end
+
+  context "digital materials" do
+    subject(:physical_description) do
+      mods_record(<<-XML).physical_description
+        <physicalDescription>
+          <reformattingQuality>preservation</reformattingQuality>
+          <internetMediaType>image/jp2</internetMediaType>
+          <digitalOrigin>reformatted digital</digitalOrigin>
+        </physicalDescription>
+      XML
+    end
+
+    it "should understand reformattingQuality child element" do
+      expect(physical_description.reformattingQuality.map(&:text)).to eq(["preservation"])
+    end
+    it "should understand digitalOrigin child element" do
+      expect(physical_description.digitalOrigin.map(&:text)).to eq(["reformatted digital"])
+    end
+    it "should understand internetMediaType child element" do
+      expect(physical_description.internetMediaType.map(&:text)).to eq(["image/jp2"])
+    end
+  end
+
+end

data/spec/{reader_spec.rb → lib/reader_spec.rb}

@@ -33,7 +33,7 @@ describe "Mods::Reader" do
 
   context "from_file" do
     before(:all) do
-      @fixture_dir = File.join(File.dirname(__FILE__), 'fixture_data')
+      @fixture_dir = File.join(File.dirname(__FILE__), '../fixture_data')
       @fixture_mods_file = File.join(@fixture_dir, 'shpc1.mods.xml')
       @from_file = Mods::Reader.new.from_file(@fixture_mods_file)
     end
@@ -48,7 +48,6 @@ describe "Mods::Reader" do
   context "namespace awareness" do
     it "should care about namespace by default" do
       r = Mods::Reader.new
-      expect(r.namespace_aware).to be_truthy
       expect(@doc_from_str_default_ns.root.namespace.href).to eq(Mods::MODS_NS)
       expect(@doc_from_str_default_ns.xpath('/m:mods/m:note', @ns_hash).text).to eq("ns")
       expect(@doc_from_str_default_ns.xpath('/mods/note').size).to eq(0)
@@ -61,24 +60,6 @@ describe "Mods::Reader" do
       expect(@doc_from_str_wrong_ns.xpath('/m:mods/m:note', @ns_hash).size).to eq(0)
       expect(@doc_from_str_wrong_ns.xpath('/mods/note').size).to eq(0)
     end
-
-    it "should be allowed not to care about namespaces" do
-      r = Mods::Reader.new(false)
-      expect(r.namespace_aware).to be_falsey
-      my_from_str_ns = r.from_str(@example_ns_str)
-      expect(my_from_str_ns.xpath('/m:mods/m:note', @ns_hash).size).to eq(0)
-      expect(my_from_str_ns.xpath('/mods/note').text).to eq("ns")
-      my_from_str_no_ns = r.from_str(@example_no_ns_str)
-      expect(my_from_str_no_ns.xpath('/m:mods/m:note', @ns_hash).size).to eq(0)
-      expect(my_from_str_no_ns.xpath('/mods/note').text).to eq("no ns")
-      my_from_str_wrong_ns = r.from_str(@example_wrong_ns_str)
-      expect(my_from_str_wrong_ns.xpath('/m:mods/m:note', @ns_hash).size).to eq(0)
-      expect(my_from_str_wrong_ns.xpath('/mods/note').text).to eq("wrong ns")
-    end
-  end
-
-  it "should do something useful when it gets unparseable XML" do
-    skip "need to implement error handling for bad xml"
   end
 
   context "normalizing mods" do
@@ -94,19 +75,6 @@ describe "Mods::Reader" do
       reader = Mods::Reader.new.from_str(utf_mods)
       expect(reader.encoding).to eql("UTF-8")
     end
-    it "should remove xsi:schemaLocation attribute from mods element if removing namespaces" do
-      str = '<ns3:mods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ns3="http://www.loc.gov/mods/v3" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-2.xsd">
-        <ns3:note>be very frightened</ns3:note></ns3:mods>'
-      ng_xml = Nokogiri::XML(str)
-      # Nokogiri treats namespaced attributes differently in jruby than in ruby
-      expect(ng_xml.root.has_attribute?('schemaLocation') || ng_xml.root.has_attribute?('xsi:schemaLocation')).to be_truthy
-      r = Mods::Reader.new
-      r.namespace_aware = false
-      r.from_nk_node(ng_xml)
-      # the below are different depending on jruby or ruby ... oy
-      expect(r.mods_ng_xml.root.attributes.keys).not_to include('schemaLocation')
-      expect(r.mods_ng_xml.root.attributes.keys).not_to include('xsi:schemaLocation')
-    end
   end
 
   context "from_nk_node" do
@@ -142,14 +110,6 @@ describe "Mods::Reader" do
     it "should care about namespace by default" do
       expect(@mods_ng_doc.xpath('/m:mods/m:titleInfo/m:title', @ns_hash).text).to eq("boo")
     end
-    it "should be able not to care about namespaces" do
-      @r.namespace_aware = false
-      mods_ng_doc = @r.from_nk_node(@mods_node)
-      expect(mods_ng_doc).to be_kind_of(Nokogiri::XML::Document)
-      expect(mods_ng_doc.xpath('/m:mods/m:titleInfo/m:title', @ns_hash).size).to eq(0)
-      expect(mods_ng_doc.xpath('/mods/titleInfo/title').text).to eq("boo")
-      @r.namespace_aware = true
-    end
   end # context from_nk_node
 
 end

data/spec/lib/record_info_spec.rb

@@ -0,0 +1,114 @@
+require 'spec_helper'
+
+RSpec.describe "Mods <recordInfo> Element" do
+  context 'with some basic record info' do
+    subject(:record_info) do
+      mods_record("<recordInfo>
+              <recordContentSource authority='marcorg'>RQE</recordContentSource>
+              <recordCreationDate encoding='marc'>890517</recordCreationDate>
+              <recordIdentifier source='SIRSI'>a9079953</recordIdentifier>
+            </recordInfo>").record_info
+    end
+
+    it 'has the expected attributes' do
+      expect(record_info.first).to have_attributes(
+        recordContentSource: match_array(have_attributes(
+          authority: 'marcorg',
+          text: 'RQE'
+        )),
+        recordCreationDate: match_array(have_attributes(
+          encoding: 'marc',
+          text: '890517'
+        )),
+        recordIdentifier: match_array(have_attributes(
+          source: 'SIRSI',
+          text: 'a9079953'
+        ))
+      )
+    end
+  end
+
+  context 'with some more expansive record info' do
+    subject(:record_info) do
+      mods_record("<recordInfo>
+                <descriptionStandard>aacr2</descriptionStandard>
+                <recordContentSource authority='marcorg'>AU@</recordContentSource>
+                <recordCreationDate encoding='marc'>050921</recordCreationDate>
+                <recordIdentifier source='SIRSI'>a8837534</recordIdentifier>
+                <languageOfCataloging>
+                  <languageTerm authority='iso639-2b' type='code'>eng</languageTerm>
+                </languageOfCataloging>
+            </recordInfo>").record_info
+    end
+
+    it 'has the expected attributes' do
+      expect(record_info.first).to have_attributes(
+        descriptionStandard: match_array(have_attributes(text: 'aacr2')),
+        recordContentSource: match_array(have_attributes(
+          authority: 'marcorg',
+          text: 'AU@'
+        )),
+        recordCreationDate: match_array(have_attributes(
+          encoding: 'marc',
+          text: '050921'
+        )),
+        recordIdentifier: match_array(have_attributes(
+          source: 'SIRSI',
+          text: 'a8837534'
+        )),
+        languageOfCataloging: match_array(have_attributes(
+          languageTerm: match_array(have_attributes(
+            authority: 'iso639-2b',
+            type_at: 'code',
+            text: 'eng'
+          ))
+        ))
+      )
+    end
+  end
+
+  context 'with an rlin record info' do
+    subject(:record_info) do
+      mods_record("<recordInfo>
+                <descriptionStandard>appm</descriptionStandard>
+                <recordContentSource authority='marcorg'>CSt</recordContentSource>
+                <recordCreationDate encoding='marc'>850416</recordCreationDate>
+                <recordChangeDate encoding='iso8601'>19991012150824.0</recordChangeDate>
+                <recordIdentifier source='CStRLIN'>a4083219</recordIdentifier>
+            </recordInfo>").record_info
+    end
+
+    it 'has the expected attributes' do
+      expect(record_info.first).to have_attributes(
+        recordChangeDate: match_array(have_attributes(
+          encoding: 'iso8601',
+          text: '19991012150824.0'
+        ))
+      )
+    end
+  end
+
+  context 'with a displayLabel' do
+    subject(:record) do
+      mods_record("<recordInfo displayLabel='val'><recordOrigin>nowhere</recordOrigin></recordInfo></mods>")
+    end
+
+    it 'has the expected attributes' do
+      expect(record.record_info.first).to have_attributes(
+        displayLabel: 'val'
+      )
+    end
+  end
+
+  context 'with a recordOrigin' do
+    subject(:record) do
+      mods_record("<recordInfo><recordOrigin>human prepared</recordOrigin></recordInfo></mods>")
+    end
+
+    it 'has the expected attributes' do
+      expect(record.record_info.first).to have_attributes(
+        recordOrigin: have_attributes(text: 'human prepared')
+      )
+    end
+  end
+end

data/spec/lib/record_spec.rb

@@ -0,0 +1,287 @@
+require 'spec_helper'
+
+describe "Mods::Record" do
+  context "from_str" do
+    before(:all) do
+      @mods_ng_doc_w_ns = mods_record('<note>default ns</note>')
+    end
+    it "should return a mods record" do
+      expect(@mods_ng_doc_w_ns).to be_a_kind_of(Mods::Record)
+    end
+    it "should have namespace aware parsing turned on by default" do
+      expect(@mods_ng_doc_w_ns.namespaces.size).to be > 0
+    end
+    it "terminology should work with Record object defaults when mods string has namespaces" do
+      expect(@mods_ng_doc_w_ns.note.map { |e| e.text }).to eq(['default ns'])
+    end
+    it "terminology should not work with Record object defaults when mods string has NO namespaces" do
+      mods_ng_doc = Mods::Record.new.from_str('<mods><note>no ns</note></mods>')
+      expect(mods_ng_doc.note.size).to eq(0)
+    end
+  end
+
+  # Be able to create a new Mods::Record from a url
+  context "from_url" do
+    before(:all) do
+      @mods_doc = Mods::Record.new.from_url('http://www.loc.gov/standards/mods/modsrdf/examples/0001.xml')
+    end
+    it "should return a mods record" do
+      expect(@mods_doc).to be_a_kind_of(Mods::Record)
+    end
+    it "should raise an error on a bad url" do
+      expect{Mods::Record.new.from_url("http://example.org/fake.xml")}.to raise_error
+    end
+  end
+
+  # Be able to create a new Mods::Record from a file
+  context "from_file" do
+    before(:all) do
+      @fixture_dir = File.join(File.dirname(__FILE__), '../fixture_data')
+      @mods_doc = Mods::Record.new.from_file(File.join(@fixture_dir, 'shpc1.mods.xml'))
+    end
+    it "should return a mods record" do
+      expect(@mods_doc).to be_a_kind_of(Mods::Record)
+    end
+  end
+
+  context "from_nk_node" do
+    before(:all) do
+      oai_resp = '<?xml version="1.0" encoding="UTF-8"?>
+      <OAI-PMH xmlns="http://www.openarchives.org/OAI/2.0/">
+      	<responseDate>2012-11-13T22:11:35Z</responseDate>
+      	<request>http://sul-lyberservices-prod.stanford.edu/sw-oai-provider/oai</request>
+      	<GetRecord>
+      		<record>
+      			<header>
+      				<identifier>oai:searchworks.stanford.edu/druid:mm848sz7984</identifier>
+      				<datestamp>2012-10-28T01:06:31Z</datestamp>
+      			</header>
+      			<metadata>
+      				<ns3:mods xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:ns3="http://www.loc.gov/mods/v3" xsi:schemaLocation="http://www.loc.gov/mods/v3 http://www.loc.gov/standards/mods/v3/mods-3-2.xsd">
+      					<ns3:titleInfo>
+      						<ns3:title>boo</ns3:title>
+      					</ns3:titleInfo>
+      				</ns3:mods>
+            </metadata>
+          </record>
+        </GetRecord>
+      </OAI-PMH>'
+      ng_xml = Nokogiri::XML(oai_resp)
+      @mods_node = ng_xml.xpath('//mods:mods', mods: 'http://www.loc.gov/mods/v3').first
+      @mods_ng_doc = Mods::Record.new.from_nk_node(@mods_node)
+      bad_ns_wrapped = '<?xml version="1.0" encoding="UTF-8"?>
+      <metadata>
+				<n:mods xmlns:n="http://www.not.mods.org">
+					<n:titleInfo>
+						<n:title>What? No namespaces?</n:title>
+					</n:titleInfo>
+				</n:mods>
+      </metadata>'
+      ng_xml = Nokogiri::XML(bad_ns_wrapped)
+      @mods_node_no_ns = ng_xml.xpath('//n:mods', {'n'=>'http://www.not.mods.org'}).first
+    end
+    it "should return a mods record" do
+      expect(@mods_ng_doc).to be_a_kind_of(Mods::Record)
+    end
+    it "should have namespace aware parsing turned on by default" do
+      expect(@mods_ng_doc.namespaces.size).to be > 0
+    end
+    it "terminology should work with Record object defaults when mods string has namespaces" do
+      expect(@mods_ng_doc.title_info.title.map { |e| e.text }).to eq(["boo"])
+    end
+    it "terminology should not work with Record object defaults when mods node has NO namespaces" do
+      mods_ng_doc = Mods::Record.new.from_nk_node(@mods_node_no_ns)
+      expect(mods_ng_doc.title_info.title.size).to eq(0)
+    end
+  end # context from_nk_node
+
+  context "getting term values" do
+    subject(:mods_rec) do
+      mods_record(<<-XML)
+        <abstract>single</abstract>
+        <genre></genre>
+        <note>mult1</note>
+        <note>mult2</note>
+        <subject><topic>topic1</topic><topic>topic2</topic></subject>
+        <subject><topic>topic3</topic></subject>
+      XML
+    end
+
+    context "term_value (single value result)" do
+      it "should return nil if there are no such values in the MODS" do
+        expect(mods_rec.term_value(:identifier)).to be_nil
+      end
+      it "should return nil if there are only empty values in the MODS" do
+        expect(mods_rec.term_value(:genre)).to be_nil
+      end
+      it "should return a String for a single value" do
+        expect(mods_rec.term_value(:abstract)).to eq('single')
+      end
+      it "should return a String containing all values, with separator, for multiple values" do
+        expect(mods_rec.term_value(:note)).to eq('mult1 mult2')
+      end
+      it "should work with an Array of messages passed as the argument" do
+        expect(mods_rec.term_value([:subject, 'topic'])).to eq('topic1 topic2 topic3')
+      end
+      it "should take a separator argument" do
+        expect(mods_rec.term_value(:note, ' -|-')).to eq('mult1 -|-mult2')
+      end
+    end
+
+    context "term_values (multiple values)" do
+      it "should return nil if there are no such values in the MODS" do
+        expect(mods_rec.term_values(:identifier)).to be_nil
+      end
+      it "should return nil if there are only empty values in the MODS" do
+        expect(mods_rec.term_values(:genre)).to be_nil
+      end
+      it "should return an array of size one for a single value" do
+        expect(mods_rec.term_values(:abstract)).to eq(['single'])
+      end
+      it "should return an array of values for multiple values" do
+        expect(mods_rec.term_values(:note)).to eq(['mult1', 'mult2'])
+      end
+      it "should work with an Array of messages passed as the argument" do
+        expect(mods_rec.term_values([:subject, 'topic'])).to eq(['topic1', 'topic2', 'topic3'])
+      end
+      it "should work with a String passed as the argument" do
+        expect(mods_rec.term_values('abstract')).to eq(['single'])
+      end
+      it "should raise an error for an unrecognized message symbol" do
+        expect { mods_rec.term_values(:not_there) }.to raise_error(ArgumentError, "term_values called with unknown argument: :not_there")
+      end
+      it "should raise an error if the argument is an Array containing non-symbols" do
+        expect { mods_rec.term_values([:subject, mods_rec.subject]) }.to raise_error(ArgumentError, /term_values called with Array containing unrecognized class:.*NodeSet.*/)
+      end
+      it "should raise an error if the argument isn't a Symbol or an Array" do
+        expect { mods_rec.term_values(mods_rec.subject) }.to raise_error(ArgumentError, /term_values called with unrecognized argument class:.*NodeSet.*/)
+      end
+    end
+  end # getting term values
+
+  context "convenience methods for accessing tricky bits of terminology" do
+    context "title methods" do
+      it "short_titles should return an Array of Strings (multiple titles are legal in Mods)" do
+        record = mods_record("<titleInfo><title>Jerk</title><nonSort>The</nonSort></titleInfo><titleInfo><title>Joke</title></titleInfo>")
+        expect(record.short_titles).to eq(["The Jerk", "Joke"])
+      end
+      it "full_titles should return an Array of Strings (multiple titles are legal in Mods)" do
+        record = mods_record("<titleInfo><title>Jerk</title><nonSort>The</nonSort></titleInfo><titleInfo><title>Joke</title></titleInfo>")
+        expect(record.full_titles).to eq(["The Jerk", "Joke"])
+      end
+      it "sort_title should return a String (sortable fields are single valued)" do
+        record = mods_record("<titleInfo><title>Jerk</title><subTitle>A Tale of Tourettes</subTitle><nonSort>The</nonSort></titleInfo>")
+        expect(record.sort_title).to eq("Jerk A Tale of Tourettes")
+      end
+      it "alternative_titles should return an Array of Strings (multiple alternative titles when there are multiple titleInfo elements)" do
+        record = mods_record("<titleInfo type='alternative'><title>1</title></titleInfo><titleInfo type='alternative'><title>2</title></titleInfo>")
+        expect(record.alternative_titles).to eq(['1', '2'])
+        record = mods_record("<titleInfo type='alternative'><title>1</title><title>2</title></titleInfo>")
+        expect(record.alternative_titles).to eq(['12'])
+      end
+    end
+
+    context "personal_names" do
+      before(:all) do
+        @pers_name = 'Crusty'
+        @pers_role = 'creator'
+        @given_family = mods_record('<name type="personal"><namePart type="given">Jorge Luis</namePart><namePart type="family">Borges</namePart></name>')
+        @given_family_date = mods_record('<name type="personal"><namePart type="given">Zaphod</namePart>
+                                <namePart type="family">Beeblebrox</namePart>
+                                <namePart type="date">1912-2362</namePart></name>')
+        @all_name_parts = mods_record('<name type="personal"><namePart type="given">Given</namePart>
+                                <namePart type="family">Family</namePart>
+                                <namePart type="termsOfAddress">Mr.</namePart>
+                                <namePart type="date">date</namePart></name>')
+        @family_only = mods_record('<name type="personal"><namePart type="family">Family</namePart></name>')
+        @given_only  = mods_record('<name type="personal"><namePart type="given">Given</namePart></name>')
+      end
+
+      it "should return an Array of Strings" do
+        record = mods_record("<name type='personal'><namePart>#{@pers_name}</namePart></name>")
+        expect(record.personal_names).to eq([@pers_name])
+      end
+
+      it "should not include the role text" do
+        record = mods_record("<name type='personal'><namePart>#{@pers_name}</namePart></name>")
+        expect(record.personal_names.first).not_to match(@pers_role)
+      end
+
+      it "should prefer displayForm over namePart pieces" do
+        display_form_and_name_parts = mods_record('<name type="personal"><namePart type="given">Jorge Luis</namePart>
+                                <namePart type="family">Borges</namePart>
+                                <displayForm>display form</displayForm></name>')
+        expect(display_form_and_name_parts.personal_names).to include("display form")
+      end
+
+      it "should put the family namePart first" do
+        expect(@given_family.personal_names.first).to match(/^Borges/)
+        expect(@given_family_date.personal_names.first).to match(/^Beeblebrox/)
+      end
+      it "should not include date" do
+        expect(@given_family_date.personal_names.first).not_to match(/19/)
+        expect(@all_name_parts.personal_names.first).not_to match('date')
+      end
+      it "should include a comma when there is both a family and a given name" do
+        expect(@all_name_parts.personal_names).to include("Family, Given Mr.")
+      end
+      it "should include multiple words in a namePart" do
+        expect(@given_family.personal_names).to include("Borges, Jorge Luis")
+      end
+      it "should not include a comma when there is only a family or given name" do
+        expect(@family_only.personal_names.first).not_to match(/,/)
+        expect(@given_only.personal_names.first).not_to match(/,/)
+      end
+      it "should include terms of address" do
+        expect(@all_name_parts.personal_names.first).to match(/Mr./)
+      end
+    end # personal_names
+
+    context "personal_names_w_dates" do
+      before(:all) do
+        @given_family = mods_record('<name type="personal"><namePart type="given">Jorge Luis</namePart>
+                                <namePart type="family">Borges</namePart></name>')
+        @given_family_date = mods_record('<name type="personal"><namePart type="given">Zaphod</namePart>
+                                <namePart type="family">Beeblebrox</namePart>
+                                <namePart type="date">1912-2362</namePart></name>')
+        @all_name_parts = mods_record('<name type="personal"><namePart type="given">Given</namePart>
+                                <namePart type="family">Family</namePart>
+                                <namePart type="termsOfAddress">Mr.</namePart>
+                                <namePart type="date">date</namePart></name>')
+      end
+      it "should return an Array of Strings" do
+        expect(@given_family_date.personal_names_w_dates).to be_an_instance_of(Array)
+      end
+      it "should include the date when it is available" do
+        expect(@given_family_date.personal_names_w_dates.first).to match(/, 1912-2362$/)
+        expect(@all_name_parts.personal_names_w_dates.first).to match(/, date$/)
+      end
+      it "should be just the personal_name if no date is available" do
+        expect(@given_family.personal_names_w_dates.first).to eq('Borges, Jorge Luis')
+      end
+    end
+
+    context "corporate_names" do
+      before(:all) do
+        @corp_name = 'ABC corp'
+      end
+      it "should return an Array of Strings" do
+        record = mods_record("<name type='corporate'><namePart>#{@corp_name}</namePart></name></mods>")
+        expect(record.corporate_names).to eq([@corp_name])
+      end
+      it "should not include the role text" do
+        corp_role = 'lithographer'
+        mods_w_corp_name_role = mods_record("<name type='corporate'><namePart>#{@corp_name}</namePart>
+          <role><roleTerm type='text'>#{corp_role}</roleTerm></role></name>")
+        expect(mods_w_corp_name_role.corporate_names.first).not_to match(corp_role)
+      end
+
+      it "should prefer displayForm over namePart pieces" do
+        display_form_and_name_parts = mods_record("<name type='corporate'><namePart>Food, Inc.</namePart>
+                                <displayForm>display form</displayForm></name>")
+        expect(display_form_and_name_parts.corporate_names).to include("display form")
+      end
+    end # corporate_names
+  end # convenience methods for tricky bits of terminology
+
+end

data/spec/lib/related_item_spec.rb

@@ -0,0 +1,124 @@
+require 'spec_helper'
+
+describe "Mods <relatedItem> Element" do
+  context 'with a bibliography' do
+    subject(:related_item) do
+      mods_record(<<-XML).related_item.first
+        <relatedItem displayLabel='Bibliography' type='host'>
+            <titleInfo>
+                <title/>
+            </titleInfo>
+            <recordInfo>
+                <recordIdentifier source='Gallica ARK'/>
+            </recordInfo>
+            <typeOfResource>text</typeOfResource>
+        </relatedItem>
+      XML
+    end
+
+    it 'has the expected attributes' do
+      expect(related_item).to have_attributes(
+        displayLabel: 'Bibliography',
+        type_at: 'host',
+        recordInfo: match_array([
+          have_attributes(recordIdentifier: match_array([have_attributes(source: 'Gallica ARK')]))
+        ]),
+        typeOfResource: match_array([have_attributes(text: 'text')])
+      )
+    end
+  end
+
+  context 'with a related item' do
+    subject(:related_items) do
+      mods_record(<<-XML).related_item
+        <relatedItem>
+          <titleInfo>
+              <title>Complete atlas, or, Distinct view of the known world</title>
+          </titleInfo>
+          <name type='personal'>
+              <namePart>Bowen, Emanuel,</namePart>
+              <namePart type='date'>d. 1767</namePart>
+          </name>
+        </relatedItem>
+        <relatedItem type='host' displayLabel='From:'>
+          <titleInfo>
+              <title>Complete atlas, or, Distinct view of the known world</title>
+          </titleInfo>
+          <name>
+              <namePart>Bowen, Emanuel, d. 1767.</namePart>
+          </name>
+          <identifier type='local'>(AuCNL)1669726</identifier>
+        </relatedItem>
+      XML
+    end
+
+    it 'has the expected attributes' do
+      expect(related_items).to match_array([
+        have_attributes(
+          displayLabel: [],
+          titleInfo: match_array([have_attributes(title: have_attributes(text: 'Complete atlas, or, Distinct view of the known world'))]),
+          personal_name: match_array([
+            have_attributes(type_at: 'personal', display_value: 'Bowen, Emanuel,', date: match_array(have_attributes(text: 'd. 1767')))
+          ])
+        ),
+        have_attributes(
+          displayLabel: 'From:',
+          type_at: 'host',
+          identifier: match_array([
+            have_attributes(type_at: 'local', text: '(AuCNL)1669726')
+          ])
+        )
+      ])
+    end
+  end
+
+  context 'with a constituent item' do
+    subject(:related_item) do
+      mods_record(<<-XML).related_item.first
+        <relatedItem type='constituent' ID='MODSMD_ARTICLE1'>
+          <titleInfo>
+              <title>Nuppineula.</title>
+          </titleInfo>
+          <genre>article</genre>
+          <part ID='DIVL15' type='paragraph' order='1'/>
+          <part ID='DIVL17' type='paragraph' order='2'/>
+          <part ID='DIVL19' type='paragraph' order='3'/>
+        </relatedItem>
+      XML
+    end
+
+    it 'has the expected attributes' do
+      expect(related_item).to have_attributes(
+        id_at: 'MODSMD_ARTICLE1',
+        type_at: 'constituent',
+        titleInfo: match_array([have_attributes(title: have_attributes(text: 'Nuppineula.'))]),
+        genre: have_attributes(text: 'article'),
+        part: match_array([
+          have_attributes(id_at: 'DIVL15', type_at: 'paragraph', order: '1'),
+          have_attributes(id_at: 'DIVL17', type_at: 'paragraph', order: '2'),
+          have_attributes(id_at: 'DIVL19', type_at: 'paragraph', order: '3')
+        ])
+      )
+    end
+  end
+
+  context 'with a collection' do
+    subject(:related_item) do
+      mods_record(<<-XML).related_item.first
+        <relatedItem type='host'>
+          <titleInfo>
+            <title>The Collier Collection of the Revs Institute for Automotive Research</title>
+          </titleInfo>
+          <typeOfResource collection='yes'/>
+        </relatedItem>
+      XML
+    end
+
+    it 'has the expected attributes' do
+      expect(related_item).to have_attributes(
+        titleInfo: match_array([have_attributes(title: have_attributes(text: 'The Collier Collection of the Revs Institute for Automotive Research'))]),
+        typeOfResource: match_array([have_attributes(collection: 'yes')])
+      )
+    end
+  end
+end