mods 2.0.1 → 2.0.2

data/lib/mods/reader.rb

@@ -19,7 +19,6 @@ module Mods
     def from_str(str)
       @mods_ng_xml = Nokogiri::XML(str, nil, str.encoding.to_s)
       normalize_mods
-      @mods_ng_xml
     end
 
     # Read in the contents of a Mods file from a url.
@@ -31,7 +30,6 @@ module Mods
       require 'open-uri'
       @mods_ng_xml = Nokogiri::XML(open(url).read)
       normalize_mods
-      @mods_ng_xml
     end
 
     # Read in the contents of a Mods record from a file.
@@ -44,7 +42,6 @@ module Mods
       @mods_ng_xml = Nokogiri::XML(file)
       file.close
       normalize_mods
-      @mods_ng_xml
     end
 
     # @param node (Nokogiri::XML::Node) - Nokogiri::XML::Node that is the top level element of a mods record
@@ -52,10 +49,10 @@ module Mods
     def from_nk_node(node)
       @mods_ng_xml = Nokogiri::XML(node.to_s, nil, node.document.encoding)
       normalize_mods
-      @mods_ng_xml
     end
 
     # Whatever we get, normalize it into a Nokogiri::XML::Document,
+    # @return mods_ng_xml (Nokogiri::XML::Document) normalized doc
     def normalize_mods
       if !@namespace_aware
         @mods_ng_xml.remove_namespaces!
@@ -68,6 +65,7 @@ module Mods
 #        @mods_ng_xml = Nokogiri::XML(@mods_ng_xml.to_s, nil, @mods_ng_xml.encoding, Nokogiri::XML::ParseOptions::PEDANTIC)
         @mods_ng_xml = Nokogiri::XML(@mods_ng_xml.to_s, nil, @mods_ng_xml.encoding)
       end
+      @mods_ng_xml
     end
 
   end # class

data/lib/mods/record.rb

@@ -24,6 +24,7 @@ module Mods
     # convenience method to call Mods::Reader.new.from_str and to nom
     # @param ns_aware true if the XML parsing should be strict about using namespaces.  Default is true
     # @param str - a string containing mods xml
+    # @return Mods::Record
     def from_str(str, ns_aware = true)
       @mods_ng_xml = Mods::Reader.new(ns_aware).from_str(str)
       if ns_aware
@@ -31,6 +32,7 @@ module Mods
       else
         set_terminology_no_ns(@mods_ng_xml)
       end
+      return self
     end
 
     # Convenience method to call Mods::Reader.new.from_url and to nom.
@@ -68,8 +70,9 @@ module Mods
     end
 
     # convenience method to call Mods::Reader.new.from_nk_node and to nom
-    # @param ns_aware true if the XML parsing should be strict about using namespaces.  Default is true
     # @param node (Nokogiri::XML::Node) - Nokogiri::XML::Node that is the top level element of a mods record
+    # @param ns_aware true if the XML parsing should be strict about using namespaces.  Default is true
+    # @return Mods::Record
     def from_nk_node(node, ns_aware = true)
       @mods_ng_xml = Mods::Reader.new(ns_aware).from_nk_node(node)
       if ns_aware
@@ -77,6 +80,7 @@ module Mods
       else
         set_terminology_no_ns(@mods_ng_xml)
       end
+      return self
     end
 
     # get the value for the terms, as a String. f there are multiple values, they will be joined with the separator.

data/lib/mods/version.rb

@@ -1,4 +1,4 @@
 module Mods
   # this is the Ruby Gem version
-  VERSION = "2.0.1"
+  VERSION = "2.0.2"
 end

data/mods.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |gem|
   gem.require_paths = ["lib"]
   
   gem.add_dependency 'nokogiri'
-  gem.add_dependency 'nom-xml'
+  gem.add_dependency 'nom-xml', '~> 0.5.2'
   gem.add_dependency 'iso-639'
 
   # Runtime dependencies
@@ -31,8 +31,8 @@ Gem::Specification.new do |gem|
   gem.add_development_dependency "rdoc"
   gem.add_development_dependency "yard"
   # tests
-	gem.add_development_dependency 'rspec', '~> 3.0'
-	# using coveralls with travis 
-	# gem.add_development_dependency 'ruby-debug19'
+  gem.add_development_dependency 'rspec', '~> 3.0'
+  # using coveralls with travis
+  # gem.add_development_dependency 'ruby-debug19'
   gem.add_development_dependency 'equivalent-xml'
 end

data/spec/language_spec.rb

@@ -19,43 +19,43 @@ describe "Mods <language> Element" do
         @ex_array = [@iso639_2b_code_ln, @mult_code_terms, @mult_text_terms]
       end
       it "should be a NodeSet" do
-        @ex_array.each { |t| t.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+        @ex_array.each { |t| expect(t).to be_an_instance_of(Nokogiri::XML::NodeSet) }
       end
       it "should have as many members as there are <language> elements in the xml" do
-        @ex_array.each { |t| t.size.should == 1 }
+        @ex_array.each { |t| expect(t.size).to eq(1) }
       end
 
       context "<languageTerm> child element" do
         it "should understand languageTerm.type_at attribute" do
-          @iso639_2b_code_ln.languageTerm.type_at.should == ["code"]
+          expect(@iso639_2b_code_ln.languageTerm.type_at).to eq(["code"])
         end
         it "should understand languageTerm.authority attribute" do
-          @iso639_2b_code_ln.languageTerm.authority.should == ["iso639-2b"]
+          expect(@iso639_2b_code_ln.languageTerm.authority).to eq(["iso639-2b"])
         end
         it "should understand languageTerm value" do
-          @iso639_2b_code_ln.languageTerm.text.should == "fre"
-          @iso639_2b_code_ln.languageTerm.size.should == 1
+          expect(@iso639_2b_code_ln.languageTerm.text).to eq("fre")
+          expect(@iso639_2b_code_ln.languageTerm.size).to eq(1)
         end
 
         it "should recognize all authority attributes" do
           Mods::AUTHORITY_ATTRIBS.each { |a|
             @mods_rec.from_str("<mods #{@ns_decl}><language><languageTerm #{a}='attr_val'>zzz</languageTerm></language></mods>")
-            @mods_rec.language.languageTerm.send(a.to_sym).should == ['attr_val']
+            expect(@mods_rec.language.languageTerm.send(a.to_sym)).to eq(['attr_val'])
           }
         end
       end # <languageTerm> 
 
       it "should get one language.code_term for each languageTerm element with a type attribute of 'code'" do
-        @iso639_2b_code_ln.code_term.size.should == 1
-        @iso639_2b_code_ln.code_term.text.should == "fre"
-        @mult_code_terms.code_term.size.should == 2
-        @mult_code_terms.code_term.first.text.should include("spa")
-        @mult_code_terms.code_term[1].text.should == "dut"
+        expect(@iso639_2b_code_ln.code_term.size).to eq(1)
+        expect(@iso639_2b_code_ln.code_term.text).to eq("fre")
+        expect(@mult_code_terms.code_term.size).to eq(2)
+        expect(@mult_code_terms.code_term.first.text).to include("spa")
+        expect(@mult_code_terms.code_term[1].text).to eq("dut")
       end
       it "should get one language.text_term for each languageTerm element with a type attribute of 'text'" do
-        @mult_text_terms.text_term.size.should == 2
-        @mult_text_terms.text_term.first.text.should include("Chinese")
-        @mult_text_terms.text_term[1].text.should == "Spanish"
+        expect(@mult_text_terms.text_term.size).to eq(2)
+        expect(@mult_text_terms.text_term.first.text).to include("Chinese")
+        expect(@mult_text_terms.text_term[1].text).to eq("Spanish")
       end
     end # namespace_aware
     
@@ -71,43 +71,43 @@ describe "Mods <language> Element" do
         @ex_array = [@iso639_2b_code_ln, @mult_code_terms, @mult_text_terms]
       end
       it "should be a NodeSet" do
-        @ex_array.each { |t| t.should be_an_instance_of(Nokogiri::XML::NodeSet) }
+        @ex_array.each { |t| expect(t).to be_an_instance_of(Nokogiri::XML::NodeSet) }
       end
       it "should have as many members as there are <language> elements in the xml" do
-        @ex_array.each { |t| t.size.should == 1 }
+        @ex_array.each { |t| expect(t.size).to eq(1) }
       end
 
       context "<languageTerm> child element" do
         it "should understand languageTerm.type_at attribute" do
-          @iso639_2b_code_ln.languageTerm.type_at.should == ["code"]
+          expect(@iso639_2b_code_ln.languageTerm.type_at).to eq(["code"])
         end
         it "should understand languageTerm.authority attribute" do
-          @iso639_2b_code_ln.languageTerm.authority.should == ["iso639-2b"]
+          expect(@iso639_2b_code_ln.languageTerm.authority).to eq(["iso639-2b"])
         end
         it "should understand languageTerm value" do
-          @iso639_2b_code_ln.languageTerm.text.should == "fre"
-          @iso639_2b_code_ln.languageTerm.size.should == 1
+          expect(@iso639_2b_code_ln.languageTerm.text).to eq("fre")
+          expect(@iso639_2b_code_ln.languageTerm.size).to eq(1)
         end
 
         it "should recognize all authority attributes" do
           Mods::AUTHORITY_ATTRIBS.each { |a|
             @mods_rec.from_str("<mods><language><languageTerm #{a}='attr_val'>zzz</languageTerm></language></mods>", false)
-            @mods_rec.language.languageTerm.send(a.to_sym).should == ['attr_val']
+            expect(@mods_rec.language.languageTerm.send(a.to_sym)).to eq(['attr_val'])
           }
         end
       end # <languageTerm> 
 
       it "should get one language.code_term for each languageTerm element with a type attribute of 'code'" do
-        @iso639_2b_code_ln.code_term.size.should == 1
-        @iso639_2b_code_ln.code_term.text.should == "fre"
-        @mult_code_terms.code_term.size.should == 2
-        @mult_code_terms.code_term.first.text.should include("spa")
-        @mult_code_terms.code_term[1].text.should == "dut"
+        expect(@iso639_2b_code_ln.code_term.size).to eq(1)
+        expect(@iso639_2b_code_ln.code_term.text).to eq("fre")
+        expect(@mult_code_terms.code_term.size).to eq(2)
+        expect(@mult_code_terms.code_term.first.text).to include("spa")
+        expect(@mult_code_terms.code_term[1].text).to eq("dut")
       end
       it "should get one language.text_term for each languageTerm element with a type attribute of 'text'" do
-        @mult_text_terms.text_term.size.should == 2
-        @mult_text_terms.text_term.first.text.should include("Chinese")
-        @mult_text_terms.text_term[1].text.should == "Spanish"
+        expect(@mult_text_terms.text_term.size).to eq(2)
+        expect(@mult_text_terms.text_term.first.text).to include("Chinese")
+        expect(@mult_text_terms.text_term[1].text).to eq("Spanish")
       end
     end # NOT namespace_aware
 

data/spec/location_spec.rb

@@ -31,17 +31,17 @@ describe "Mods <location> Element" do
         end
         it "should have access to text value of element" do
           @mods_rec.from_str(@phys_loc_only)
-          @mods_rec.location.physicalLocation.text.should == "here"
+          expect(@mods_rec.location.physicalLocation.text).to eq("here")
           @mods_rec.from_str(@phys_loc_authority)
-          @mods_rec.location.physicalLocation.map { |n| n.text }.should == ["MnRM"]
+          expect(@mods_rec.location.physicalLocation.map { |n| n.text }).to eq(["MnRM"])
         end
         it "should recognize authority attribute" do
           @mods_rec.from_str(@phys_loc_authority)
-          @mods_rec.location.physicalLocation.authority.should == ["marcorg"]
+          expect(@mods_rec.location.physicalLocation.authority).to eq(["marcorg"])
         end
         it "should recognize displayLabel attribute" do
           @mods_rec.from_str("<mods #{@ns_decl}><location><physicalLocation displayLabel='Correspondence'>some address</physicalLocation></location></mods>")
-          @mods_rec.location.physicalLocation.displayLabel.should == ["Correspondence"]
+          expect(@mods_rec.location.physicalLocation.displayLabel).to eq(["Correspondence"])
         end      
       end
 
@@ -51,7 +51,7 @@ describe "Mods <location> Element" do
                         	<shelfLocator>DAG no. 1410</shelfLocator>
                       </location></mods>"
         @mods_rec.from_str(shelf_loc)
-        @mods_rec.location.shelfLocator.map { |n| n.text }.should == ["DAG no. 1410"]
+        expect(@mods_rec.location.shelfLocator.map { |n| n.text }).to eq(["DAG no. 1410"])
       end
 
       context "url child element" do
@@ -65,10 +65,10 @@ describe "Mods <location> Element" do
         end
         it "should have access to text value of element" do
           urls = @mods_rec.from_str(@mult_flavor_loc_urls).location.url.map { |e| e.text }
-          urls.size.should == 3
-          urls.should include("http://preview.org")
-          urls.should include("http://context.org")
-          urls.should include("http://object.org")
+          expect(urls.size).to eq(3)
+          expect(urls).to include("http://preview.org")
+          expect(urls).to include("http://context.org")
+          expect(urls).to include("http://object.org")
         end
         context "attributes" do
           before(:all) do
@@ -77,29 +77,29 @@ describe "Mods <location> Element" do
                       </location></mods>"
           end
           it "should recognize displayLabel attribute" do
-            @mods_rec.from_str(@url_attribs).location.url.displayLabel.should == ["Digital collection of 46 images available online"]
+            expect(@mods_rec.from_str(@url_attribs).location.url.displayLabel).to eq(["Digital collection of 46 images available online"])
           end
           it "should recognize access attribute" do
             vals = @mods_rec.from_str(@mult_flavor_loc_urls).location.url.access
-            vals.size.should == 3
-            vals.should include("preview")
-            vals.should include("object in context")
-            vals.should include("raw object")
+            expect(vals.size).to eq(3)
+            expect(vals).to include("preview")
+            expect(vals).to include("object in context")
+            expect(vals).to include("raw object")
           end
           it "should recognize usage attribute" do
-            @mods_rec.from_str(@url_attribs).location.url.usage.should == ["primary display"]
+            expect(@mods_rec.from_str(@url_attribs).location.url.usage).to eq(["primary display"])
           end
           it "should recognize note attribute" do
             @mods_rec.from_str("<mods #{@ns_decl}><location><url note='something'>http://somewhere.org</url></location></mods>")
-            @mods_rec.location.url.note.should == ["something"]
+            expect(@mods_rec.location.url.note).to eq(["something"])
           end
           it "should recognize dateLastAccessed attribute" do
             @mods_rec.from_str("<mods #{@ns_decl}><location><url dateLastAccessed='something'>http://somewhere.org</url></location></mods>")
-            @mods_rec.location.url.dateLastAccessed.should == ["something"]
+            expect(@mods_rec.location.url.dateLastAccessed).to eq(["something"])
           end
         end # attributes
         it "should have array with empty string for single empty url element" do
-          @mods_rec.from_str(@empty_loc_url).location.url.map { |n| n.text }.should == [""]
+          expect(@mods_rec.from_str(@empty_loc_url).location.url.map { |n| n.text }).to eq([""])
         end
       end # url child element
 
@@ -113,8 +113,8 @@ describe "Mods <location> Element" do
           	  	  	<enumerationAndChronology unitType='1'> v.1-v.8 1970-1976</enumerationAndChronology>
           	  	</copyInformation>
           	</holdingSimple></location></mods>"
-        @mods_rec.from_str(xml).location.holdingSimple.should be_an_instance_of(Nokogiri::XML::NodeSet)
-        @mods_rec.from_str(xml).location.holdingSimple.first.should be_an_instance_of(Nokogiri::XML::Element)
+        expect(@mods_rec.from_str(xml).location.holdingSimple).to be_an_instance_of(Nokogiri::XML::NodeSet)
+        expect(@mods_rec.from_str(xml).location.holdingSimple.first).to be_an_instance_of(Nokogiri::XML::Element)
       end
       it "holdingComplex child element" do
         xml = "<mods #{@ns_decl}>
@@ -143,8 +143,8 @@ describe "Mods <location> Element" do
           	  	</holding> 	  	  	 
           	  	  	  	</holdingExternal>
             </mods>"
-        @mods_rec.from_str(xml).location.holdingExternal.should be_an_instance_of(Nokogiri::XML::NodeSet)
-        @mods_rec.from_str(xml).location.holdingExternal.first.should be_an_instance_of(Nokogiri::XML::Element)
+        expect(@mods_rec.from_str(xml).location.holdingExternal).to be_an_instance_of(Nokogiri::XML::NodeSet)
+        expect(@mods_rec.from_str(xml).location.holdingExternal.first).to be_an_instance_of(Nokogiri::XML::Element)
       end
 
     end # WITH namespaces
@@ -172,17 +172,17 @@ describe "Mods <location> Element" do
         end
         it "should have access to text value of element" do
           @mods_rec.from_str(@phys_loc_only, false)
-          @mods_rec.location.physicalLocation.text.should == "here"
+          expect(@mods_rec.location.physicalLocation.text).to eq("here")
           @mods_rec.from_str(@phys_loc_authority, false)
-          @mods_rec.location.physicalLocation.map { |n| n.text }.should == ["MnRM"]
+          expect(@mods_rec.location.physicalLocation.map { |n| n.text }).to eq(["MnRM"])
         end
         it "should recognize authority attribute" do
           @mods_rec.from_str(@phys_loc_authority, false)
-          @mods_rec.location.physicalLocation.authority.should == ["marcorg"]
+          expect(@mods_rec.location.physicalLocation.authority).to eq(["marcorg"])
         end
         it "should recognize displayLabel attribute" do
           @mods_rec.from_str('<mods><location><physicalLocation displayLabel="Correspondence">some address</physicalLocation></location></mods>', false)
-          @mods_rec.location.physicalLocation.displayLabel.should == ["Correspondence"]
+          expect(@mods_rec.location.physicalLocation.displayLabel).to eq(["Correspondence"])
         end      
       end
 
@@ -192,7 +192,7 @@ describe "Mods <location> Element" do
                         	<shelfLocator>DAG no. 1410</shelfLocator>
                       </location></mods>'
         @mods_rec.from_str(shelf_loc, false)
-        @mods_rec.location.shelfLocator.map { |n| n.text }.should == ["DAG no. 1410"]
+        expect(@mods_rec.location.shelfLocator.map { |n| n.text }).to eq(["DAG no. 1410"])
       end
 
       context "url child element" do
@@ -206,10 +206,10 @@ describe "Mods <location> Element" do
         end
         it "should have access to text value of element" do
           urls = @mods_rec.from_str(@mult_flavor_loc_urls, false).location.url.map { |e| e.text }
-          urls.size.should == 3
-          urls.should include("http://preview.org")
-          urls.should include("http://context.org")
-          urls.should include("http://object.org")
+          expect(urls.size).to eq(3)
+          expect(urls).to include("http://preview.org")
+          expect(urls).to include("http://context.org")
+          expect(urls).to include("http://object.org")
         end
         context "attributes" do
           before(:all) do
@@ -218,29 +218,29 @@ describe "Mods <location> Element" do
                       </location></mods>'
           end
           it "should recognize displayLabel attribute" do
-            @mods_rec.from_str(@url_attribs, false).location.url.displayLabel.should == ["Digital collection of 46 images available online"]
+            expect(@mods_rec.from_str(@url_attribs, false).location.url.displayLabel).to eq(["Digital collection of 46 images available online"])
           end
           it "should recognize access attribute" do
             vals = @mods_rec.from_str(@mult_flavor_loc_urls, false).location.url.access
-            vals.size.should == 3
-            vals.should include("preview")
-            vals.should include("object in context")
-            vals.should include("raw object")
+            expect(vals.size).to eq(3)
+            expect(vals).to include("preview")
+            expect(vals).to include("object in context")
+            expect(vals).to include("raw object")
           end
           it "should recognize usage attribute" do
-            @mods_rec.from_str(@url_attribs, false).location.url.usage.should == ["primary display"]
+            expect(@mods_rec.from_str(@url_attribs, false).location.url.usage).to eq(["primary display"])
           end
           it "should recognize note attribute" do
             @mods_rec.from_str('<mods><location><url note="something">http://somewhere.org</url></location></mods>', false)
-            @mods_rec.location.url.note.should == ["something"]
+            expect(@mods_rec.location.url.note).to eq(["something"])
           end
           it "should recognize dateLastAccessed attribute" do
             @mods_rec.from_str('<mods><location><url dateLastAccessed="something">http://somewhere.org</url></location></mods>', false)
-            @mods_rec.location.url.dateLastAccessed.should == ["something"]
+            expect(@mods_rec.location.url.dateLastAccessed).to eq(["something"])
           end
         end # attributes
         it "should have array with empty string for single empty url element" do
-          @mods_rec.from_str(@empty_loc_url, false).location.url.map { |n| n.text }.should == [""]
+          expect(@mods_rec.from_str(@empty_loc_url, false).location.url.map { |n| n.text }).to eq([""])
         end
       end # url child element
 
@@ -254,8 +254,8 @@ describe "Mods <location> Element" do
           	  	  	<enumerationAndChronology unitType="1"> v.1-v.8 1970-1976</enumerationAndChronology>
           	  	</copyInformation>
           	</holdingSimple></location></mods>'
-        @mods_rec.from_str(xml, false).location.holdingSimple.should be_an_instance_of(Nokogiri::XML::NodeSet)
-        @mods_rec.from_str(xml, false).location.holdingSimple.first.should be_an_instance_of(Nokogiri::XML::Element)
+        expect(@mods_rec.from_str(xml, false).location.holdingSimple).to be_an_instance_of(Nokogiri::XML::NodeSet)
+        expect(@mods_rec.from_str(xml, false).location.holdingSimple.first).to be_an_instance_of(Nokogiri::XML::Element)
       end
       it "holdingComplex child element" do
         xml = '<mods>
@@ -284,8 +284,8 @@ describe "Mods <location> Element" do
           	  	</holding> 	  	  	 
           	  	  	  	</holdingExternal>
             </mods>'
-        @mods_rec.from_str(xml, false).location.holdingExternal.should be_an_instance_of(Nokogiri::XML::NodeSet)
-        @mods_rec.from_str(xml, false).location.holdingExternal.first.should be_an_instance_of(Nokogiri::XML::Element)
+        expect(@mods_rec.from_str(xml, false).location.holdingExternal).to be_an_instance_of(Nokogiri::XML::NodeSet)
+        expect(@mods_rec.from_str(xml, false).location.holdingExternal.first).to be_an_instance_of(Nokogiri::XML::Element)
       end
 
     end # WITHOUT namespaces

data/spec/name_spec.rb

@@ -48,37 +48,37 @@ describe "Mods <name> Element" do
         Mods::Name::CHILD_ELEMENTS.reject{|e| e == "role"}.each { |e|
           @mods_rec.from_str("<mods #{@ns_decl}><name type='personal'><#{e}>oofda</#{e}></name></mods>")
           if e == 'description'
-            @mods_rec.personal_name.description_el.text.should == 'oofda'
+            expect(@mods_rec.personal_name.description_el.text).to eq('oofda')
           else
-            @mods_rec.personal_name.send(e).text.should == 'oofda'
+            expect(@mods_rec.personal_name.send(e).text).to eq('oofda')
           end
         }
       end
       it "should include name elements with type attr = personal" do
         @mods_rec.from_str(@mods_w_pers_name_ns)
-        @mods_rec.personal_name.namePart.text.should == @pers_name
-        @mods_rec.from_str(@mods_w_both_ns).personal_name.namePart.text.should == @pers_name
+        expect(@mods_rec.personal_name.namePart.text).to eq(@pers_name)
+        expect(@mods_rec.from_str(@mods_w_both_ns).personal_name.namePart.text).to eq(@pers_name)
       end
       it "should not include name elements with type attr != personal" do
         @mods_rec.from_str(@mods_w_corp_name_ns)
-        @mods_rec.personal_name.namePart.text.should == ""
-        @mods_rec.from_str(@mods_w_both_ns).personal_name.namePart.text.should_not match(@corp_name)
+        expect(@mods_rec.personal_name.namePart.text).to eq("")
+        expect(@mods_rec.from_str(@mods_w_both_ns).personal_name.namePart.text).not_to match(@corp_name)
       end
 
       context "roles" do
         it "should be possible to access a personal_name role easily" do
           @mods_rec.from_str(@mods_w_pers_name_role_ns)
-          @mods_rec.personal_name.role.roleTerm.text.should include(@pers_role)
+          expect(@mods_rec.personal_name.role.roleTerm.text).to include(@pers_role)
         end
         it "should get role type" do
           @mods_rec.from_str(@mods_w_pers_name_role_ns)
-          @mods_rec.personal_name.role.roleTerm.type_at.should == ["text"]
+          expect(@mods_rec.personal_name.role.roleTerm.type_at).to eq(["text"])
           @mods_rec.from_str(@mods_w_pers_name_role_code_ns)
-          @mods_rec.personal_name.role.roleTerm.type_at.should == ["code"]
+          expect(@mods_rec.personal_name.role.roleTerm.type_at).to eq(["code"])
         end
         it "should get role authority" do
           @mods_rec.from_str(@mods_w_pers_name_role_ns)
-          @mods_rec.personal_name.role.roleTerm.authority.should == ["marcrelator"]
+          expect(@mods_rec.personal_name.role.roleTerm.authority).to eq(["marcrelator"])
         end
       end # roles
     end # WITH namespaces (personal name)
@@ -88,37 +88,37 @@ describe "Mods <name> Element" do
         Mods::Name::CHILD_ELEMENTS.reject{|e| e == "role"}.each { |e|
           @mods_rec.from_str("<mods><name type='personal'><#{e}>oofda</#{e}></name></mods>", false)
           if e == 'description'
-            @mods_rec.personal_name.description_el.text.should == 'oofda'
+            expect(@mods_rec.personal_name.description_el.text).to eq('oofda')
           else
-            @mods_rec.personal_name.send(e).text.should == 'oofda'
+            expect(@mods_rec.personal_name.send(e).text).to eq('oofda')
           end
         }
       end
       it "should include name elements with type attr = personal" do
         @mods_rec.from_str(@mods_w_pers_name, false)
-        @mods_rec.personal_name.namePart.text.should == @pers_name
-        @mods_rec.from_str(@mods_w_both, false).personal_name.namePart.text.should == @pers_name
+        expect(@mods_rec.personal_name.namePart.text).to eq(@pers_name)
+        expect(@mods_rec.from_str(@mods_w_both, false).personal_name.namePart.text).to eq(@pers_name)
       end
       it "should not include name elements with type attr != personal" do
         @mods_rec.from_str(@mods_w_corp_name, false)
-        @mods_rec.personal_name.namePart.text.should == ""
-        @mods_rec.from_str(@mods_w_both, false).personal_name.namePart.text.should_not match(@corp_name)
+        expect(@mods_rec.personal_name.namePart.text).to eq("")
+        expect(@mods_rec.from_str(@mods_w_both, false).personal_name.namePart.text).not_to match(@corp_name)
       end
 
       context "roles" do
         it "should be possible to access a personal_name role easily" do
           @mods_rec.from_str(@mods_w_pers_name_role, false)
-          @mods_rec.personal_name.role.text.should include(@pers_role)
+          expect(@mods_rec.personal_name.role.text).to include(@pers_role)
         end
         it "should get role type" do
           @mods_rec.from_str(@mods_w_pers_name_role, false)
-          @mods_rec.personal_name.role.roleTerm.type_at.should == ["text"]
+          expect(@mods_rec.personal_name.role.roleTerm.type_at).to eq(["text"])
           @mods_rec.from_str(@mods_w_pers_name_role_code, false)
-          @mods_rec.personal_name.role.roleTerm.type_at.should == ["code"]
+          expect(@mods_rec.personal_name.role.roleTerm.type_at).to eq(["code"])
         end
         it "should get role authority" do
           @mods_rec.from_str(@mods_w_pers_name_role, false)
-          @mods_rec.personal_name.role.roleTerm.authority.should == ["marcrelator"]
+          expect(@mods_rec.personal_name.role.roleTerm.authority).to eq(["marcrelator"])
         end
       end # roles    
     end # WITHOUT namespaces
@@ -133,21 +133,21 @@ describe "Mods <name> Element" do
         Mods::Name::CHILD_ELEMENTS.reject{|e| e == "role" }.each { |e|
           @mods_rec.from_str("<mods #{@ns_decl}><name type='corporate'><#{e}>oofda</#{e}></name></mods>")
           if e == 'description'
-            @mods_rec.corporate_name.description_el.text.should == 'oofda'
+            expect(@mods_rec.corporate_name.description_el.text).to eq('oofda')
           else
-            @mods_rec.corporate_name.send(e).text.should == 'oofda'
+            expect(@mods_rec.corporate_name.send(e).text).to eq('oofda')
           end
         }
       end
       it "should include name elements with type attr = corporate" do
         @mods_rec.from_str(@mods_w_corp_name_ns)
-        @mods_rec.corporate_name.namePart.text.should == @corp_name
-        @mods_rec.from_str(@mods_w_both_ns).corporate_name.namePart.text.should == @corp_name
+        expect(@mods_rec.corporate_name.namePart.text).to eq(@corp_name)
+        expect(@mods_rec.from_str(@mods_w_both_ns).corporate_name.namePart.text).to eq(@corp_name)
       end
       it "should not include name elements with type attr != corporate" do
         @mods_rec.from_str(@mods_w_pers_name_ns)
-        @mods_rec.corporate_name.namePart.text.should == ""
-        @mods_rec.from_str(@mods_w_both_ns).corporate_name.namePart.text.should_not match(@pers_name)
+        expect(@mods_rec.corporate_name.namePart.text).to eq("")
+        expect(@mods_rec.from_str(@mods_w_both_ns).corporate_name.namePart.text).not_to match(@pers_name)
       end
     end # WITH namespaces
     context "WITHOUT namespaces" do
@@ -155,21 +155,21 @@ describe "Mods <name> Element" do
         Mods::Name::CHILD_ELEMENTS.reject{|e| e == "role" }.each { |e|
           @mods_rec.from_str("<mods><name type='corporate'><#{e}>oofda</#{e}></name></mods>", false)
           if e == 'description'
-            @mods_rec.corporate_name.description_el.text.should == 'oofda'
+            expect(@mods_rec.corporate_name.description_el.text).to eq('oofda')
           else
-            @mods_rec.corporate_name.send(e).text.should == 'oofda'
+            expect(@mods_rec.corporate_name.send(e).text).to eq('oofda')
           end
         }
       end
       it "should include name elements with type attr = corporate" do
         @mods_rec.from_str(@mods_w_corp_name, false)
-        @mods_rec.corporate_name.namePart.text.should == @corp_name
-        @mods_rec.from_str(@mods_w_both, false).corporate_name.namePart.text.should == @corp_name
+        expect(@mods_rec.corporate_name.namePart.text).to eq(@corp_name)
+        expect(@mods_rec.from_str(@mods_w_both, false).corporate_name.namePart.text).to eq(@corp_name)
       end
       it "should not include name elements with type attr != corporate" do
         @mods_rec.from_str(@mods_w_pers_name, false)
-        @mods_rec.corporate_name.namePart.text.should == ""
-        @mods_rec.from_str(@mods_w_both, false).corporate_name.namePart.text.should_not match(@pers_name)
+        expect(@mods_rec.corporate_name.namePart.text).to eq("")
+        expect(@mods_rec.from_str(@mods_w_both, false).corporate_name.namePart.text).not_to match(@pers_name)
       end
     end # WITHOUT namespaces
     
@@ -185,9 +185,9 @@ describe "Mods <name> Element" do
         Mods::Name::CHILD_ELEMENTS.reject{|e| e == "role"}.each { |e|
           @mods_rec.from_str("<mods #{@ns_decl}><name><#{e}>oofda</#{e}></name></mods>")
           if e == 'description'
-            @mods_rec.plain_name.description_el.text.should == 'oofda'
+            expect(@mods_rec.plain_name.description_el.text).to eq('oofda')
           else
-            @mods_rec.plain_name.send(e).text.should == 'oofda'
+            expect(@mods_rec.plain_name.send(e).text).to eq('oofda')
           end
         }
       end
@@ -195,9 +195,9 @@ describe "Mods <name> Element" do
         Mods::Name::ATTRIBUTES.each { |attrb| 
           @mods_rec.from_str("<mods #{@ns_decl}><name #{attrb}='hello'><displayForm>q</displayForm></name></mods>")
           if attrb != 'type'
-            @mods_rec.plain_name.send(attrb).should == ['hello']
+            expect(@mods_rec.plain_name.send(attrb)).to eq(['hello'])
           else
-            @mods_rec.plain_name.type_at.should == ['hello']
+            expect(@mods_rec.plain_name.type_at).to eq(['hello'])
           end
         }
       end
@@ -205,20 +205,20 @@ describe "Mods <name> Element" do
         it "should recognize type attribute on namePart element" do
           Mods::Name::NAME_PART_TYPES.each { |t|  
             @mods_rec.from_str("<mods #{@ns_decl}><name><namePart type='#{t}'>hi</namePart></name></mods>")
-            @mods_rec.plain_name.namePart.type_at.should == [t]
+            expect(@mods_rec.plain_name.namePart.type_at).to eq([t])
           }
         end
       end
       context "role child element" do
         it "should get role type" do
           @mods_rec.from_str(@mods_w_pers_name_role_ns)
-          @mods_rec.plain_name.role.roleTerm.type_at.should == ["text"]
+          expect(@mods_rec.plain_name.role.roleTerm.type_at).to eq(["text"])
           @mods_rec.from_str(@mods_w_pers_name_role_code_ns)
-          @mods_rec.plain_name.role.roleTerm.type_at.should == ["code"]
+          expect(@mods_rec.plain_name.role.roleTerm.type_at).to eq(["code"])
         end
         it "should get role authority" do
           @mods_rec.from_str(@mods_w_pers_name_role_ns)
-          @mods_rec.plain_name.role.roleTerm.authority.should == ["marcrelator"]
+          expect(@mods_rec.plain_name.role.roleTerm.authority).to eq(["marcrelator"])
         end
       end
       
@@ -229,9 +229,9 @@ describe "Mods <name> Element" do
         Mods::Name::CHILD_ELEMENTS.reject{|e| e == "role"}.each { |e|
           @mods_rec.from_str("<mods><name><#{e}>oofda</#{e}></name></mods>", false)
           if e == 'description'
-            @mods_rec.plain_name.description_el.text.should == 'oofda'
+            expect(@mods_rec.plain_name.description_el.text).to eq('oofda')
           else
-            @mods_rec.plain_name.send(e).text.should == 'oofda'
+            expect(@mods_rec.plain_name.send(e).text).to eq('oofda')
           end
         }
       end
@@ -239,9 +239,9 @@ describe "Mods <name> Element" do
         Mods::Name::ATTRIBUTES.each { |attrb| 
           @mods_rec.from_str("<mods><name #{attrb}='hello'><displayForm>q</displayForm></name></mods>", false)
           if attrb != 'type'
-            @mods_rec.plain_name.send(attrb).should == ['hello']
+            expect(@mods_rec.plain_name.send(attrb)).to eq(['hello'])
           else
-            @mods_rec.plain_name.type_at.should == ['hello']
+            expect(@mods_rec.plain_name.type_at).to eq(['hello'])
           end
         }
       end
@@ -249,20 +249,20 @@ describe "Mods <name> Element" do
         it "should recognize type attribute on namePart element" do
           Mods::Name::NAME_PART_TYPES.each { |t|  
             @mods_rec.from_str("<mods><name><namePart type='#{t}'>hi</namePart></name></mods>", false)
-            @mods_rec.plain_name.namePart.type_at.should == [t]
+            expect(@mods_rec.plain_name.namePart.type_at).to eq([t])
           }
         end
       end
       context "role child element" do
         it "should get role type" do
           @mods_rec.from_str(@mods_w_pers_name_role, false)
-          @mods_rec.plain_name.role.roleTerm.type_at.should == ["text"]
+          expect(@mods_rec.plain_name.role.roleTerm.type_at).to eq(["text"])
           @mods_rec.from_str(@mods_w_pers_name_role_code, false)
-          @mods_rec.plain_name.role.roleTerm.type_at.should == ["code"]
+          expect(@mods_rec.plain_name.role.roleTerm.type_at).to eq(["code"])
         end
         it "should get role authority" do
           @mods_rec.from_str(@mods_w_pers_name_role, false)
-          @mods_rec.plain_name.role.roleTerm.authority.should == ["marcrelator"]
+          expect(@mods_rec.plain_name.role.roleTerm.authority).to eq(["marcrelator"])
         end
       end
     end # context WITHOUT namespaces
@@ -270,7 +270,7 @@ describe "Mods <name> Element" do
   end # plain name
   
   it "should be able to translate the marc relator code into text" do
-    MARC_RELATOR['drt'].should == "Director"
+    expect(MARC_RELATOR['drt']).to eq("Director")
   end
   
   context "display_value and display_value_w_date" do
@@ -306,47 +306,47 @@ describe "Mods <name> Element" do
         @mods_namepart_date = Mods::Record.new.from_str(@namepart_xml)        
       end
       it "should be a string value for each name, not an Array" do
-        @mods_name.plain_name.first.display_value.should be_an_instance_of(String)
-        @mods_name.plain_name.first.display_value_w_date.should be_an_instance_of(String)
+        expect(@mods_name.plain_name.first.display_value).to be_an_instance_of(String)
+        expect(@mods_name.plain_name.first.display_value_w_date).to be_an_instance_of(String)
       end
       it "should return nil when there is no display_value" do
         x = "<mods #{@ns_decl}><name>
                   <namePart></namePart>
               </name></mods>"
         r = Mods::Record.new.from_str(x)
-        r.plain_name.first.display_value.should == nil
+        expect(r.plain_name.first.display_value).to eq(nil)
       end
       it "should be applicable to all name term flavors (plain_name, personal_name, corporate_name ...)" do
-        @mods_name.plain_name.first.display_value.should_not == nil
-        @mods_name.plain_name.first.display_value_w_date.should_not == nil
-        @mods_pname1.personal_name.first.display_value.should_not == nil
-        @mods_pname1.personal_name.first.display_value_w_date.should_not == nil
-        @mods_cname.corporate_name.first.display_value.should_not == nil
-        @mods_cname.corporate_name.first.display_value_w_date.should_not == nil
+        expect(@mods_name.plain_name.first.display_value).not_to eq(nil)
+        expect(@mods_name.plain_name.first.display_value_w_date).not_to eq(nil)
+        expect(@mods_pname1.personal_name.first.display_value).not_to eq(nil)
+        expect(@mods_pname1.personal_name.first.display_value_w_date).not_to eq(nil)
+        expect(@mods_cname.corporate_name.first.display_value).not_to eq(nil)
+        expect(@mods_cname.corporate_name.first.display_value_w_date).not_to eq(nil)
       end
       it "should not include <affiliation> text" do
-        @mods_name.plain_name.first.display_value.should_not =~ Regexp.new(@affl)
+        expect(@mods_name.plain_name.first.display_value).not_to match(Regexp.new(@affl))
       end
       it "should not include <description> text" do
-        @mods_name.plain_name.first.display_value.should_not =~  Regexp.new(@desc)
+        expect(@mods_name.plain_name.first.display_value).not_to match(Regexp.new(@desc))
       end
       it "should not include <role> info" do
-        @mods_name.plain_name.first.display_value.should_not =~  Regexp.new(@role)
+        expect(@mods_name.plain_name.first.display_value).not_to match(Regexp.new(@role))
       end
       it "should be the value of the <displayForm> subelement if it exists" do
-        @mods_pname1.plain_name.first.display_value.should == @disp_form
+        expect(@mods_pname1.plain_name.first.display_value).to eq(@disp_form)
         x = "<mods #{@ns_decl}><name type='personal'>
               	  <namePart>Alterman, Eric</namePart>
               	  <displayForm>Eric Alterman</displayForm>
               </name><mods>"
         r = Mods::Record.new.from_str(x)         
-        r.plain_name.first.display_value.should == 'Eric Alterman'
+        expect(r.plain_name.first.display_value).to eq('Eric Alterman')
       end
       it "display_value should not include <namePart type='date'>" do
-        @mods_namepart_date.plain_name.first.display_value.should == 'Suzy'
+        expect(@mods_namepart_date.plain_name.first.display_value).to eq('Suzy')
       end
       it "date text should be added to display_value_w_date when it is available" do
-        @mods_namepart_date.plain_name.first.display_value_w_date.should == 'Suzy, 1920-'
+        expect(@mods_namepart_date.plain_name.first.display_value_w_date).to eq('Suzy, 1920-')
       end
       it "date text should not be added to display_value_w_dates if dates are already included" do
         x = "<mods #{@ns_decl}><name>
@@ -355,7 +355,7 @@ describe "Mods <name> Element" do
                   <displayForm>Woolf, Virginia, 1882-1941</namePart>
               </name></mods>"
         r = Mods::Record.new.from_str(x) 
-        r.plain_name.first.display_value_w_date.should == 'Woolf, Virginia, 1882-1941'
+        expect(r.plain_name.first.display_value_w_date).to eq('Woolf, Virginia, 1882-1941')
       end
       context "personal names" do
         before(:all) do
@@ -384,20 +384,20 @@ describe "Mods <name> Element" do
                   <namePart type='family'>Huston</namePart>
              </name></mods>"
           r = Mods::Record.new.from_str(x)
-          r.personal_name.first.display_value.should == 'Huston, John'
-          @pope.personal_name.first.display_value.should == 'John Paul II, Pope'
+          expect(r.personal_name.first.display_value).to eq('Huston, John')
+          expect(@pope.personal_name.first.display_value).to eq('John Paul II, Pope')
         end
         it "should be concatenation of untyped <namePart> elements if there is no family or given name" do
-          @pname2.personal_name.first.display_value.should == 'Crusty The Clown'
+          expect(@pname2.personal_name.first.display_value).to eq('Crusty The Clown')
         end
         it "should include <termOfAddress> elements, in order, comma separated" do
-          @pope.personal_name.first.display_value.should == 'John Paul II, Pope'
+          expect(@pope.personal_name.first.display_value).to eq('John Paul II, Pope')
         end
         it "display_value should not include date" do
-          @pope.personal_name.first.display_value.should_not =~ Regexp.new(@d)
+          expect(@pope.personal_name.first.display_value).not_to match(Regexp.new(@d))
         end
         it "date should be included in display_value_w_date" do
-          @pope.personal_name.first.display_value_w_date.should == "John Paul II, Pope, #{@d}"
+          expect(@pope.personal_name.first.display_value_w_date).to eq("John Paul II, Pope, #{@d}")
         end
       end
       context "not personal name (e.g. corporate)" do
@@ -407,7 +407,7 @@ describe "Mods <name> Element" do
             	<namePart>Court of Appeals (2nd Circuit)</namePart>
           </name></mods>"
           r = Mods::Record.new.from_str(x)
-          r.corporate_name.first.display_value.should == 'United States Court of Appeals (2nd Circuit)'
+          expect(r.corporate_name.first.display_value).to eq('United States Court of Appeals (2nd Circuit)')
         end
       end
     end # WITH namespaces
@@ -420,47 +420,47 @@ describe "Mods <name> Element" do
         @mods_namepart_date = Mods::Record.new.from_str(@namepart_xml.sub(" #{@ns_decl}", ''), false)
       end
       it "should be a string value for each name, not an Array" do
-        @mods_name.plain_name.first.display_value.should be_an_instance_of(String)
-        @mods_name.plain_name.first.display_value_w_date.should be_an_instance_of(String)
+        expect(@mods_name.plain_name.first.display_value).to be_an_instance_of(String)
+        expect(@mods_name.plain_name.first.display_value_w_date).to be_an_instance_of(String)
       end
       it "should return nil when there is no display_value" do
         x = "<mods><name>
                   <namePart></namePart>
               </name></mods>"
         r = Mods::Record.new.from_str(x, false)
-        r.plain_name.first.display_value.should == nil
+        expect(r.plain_name.first.display_value).to eq(nil)
       end
       it "should be applicable to all name term flavors (plain_name, personal_name, corporate_name ...)" do
-        @mods_name.plain_name.first.display_value.should_not == nil
-        @mods_name.plain_name.first.display_value_w_date.should_not == nil
-        @mods_pname1.personal_name.first.display_value.should_not == nil
-        @mods_pname1.personal_name.first.display_value_w_date.should_not == nil
-        @mods_cname.corporate_name.first.display_value.should_not == nil
-        @mods_cname.corporate_name.first.display_value_w_date.should_not == nil
+        expect(@mods_name.plain_name.first.display_value).not_to eq(nil)
+        expect(@mods_name.plain_name.first.display_value_w_date).not_to eq(nil)
+        expect(@mods_pname1.personal_name.first.display_value).not_to eq(nil)
+        expect(@mods_pname1.personal_name.first.display_value_w_date).not_to eq(nil)
+        expect(@mods_cname.corporate_name.first.display_value).not_to eq(nil)
+        expect(@mods_cname.corporate_name.first.display_value_w_date).not_to eq(nil)
       end
       it "should not include <affiliation> text" do
-        @mods_name.plain_name.first.display_value.should_not =~ Regexp.new(@affl)
+        expect(@mods_name.plain_name.first.display_value).not_to match(Regexp.new(@affl))
       end
       it "should not include <description> text" do
-        @mods_name.plain_name.first.display_value.should_not =~  Regexp.new(@desc)
+        expect(@mods_name.plain_name.first.display_value).not_to match(Regexp.new(@desc))
       end
       it "should not include <role> info" do
-        @mods_name.plain_name.first.display_value.should_not =~  Regexp.new(@role)
+        expect(@mods_name.plain_name.first.display_value).not_to match(Regexp.new(@role))
       end
       it "should be the value of the <displayForm> subelement if it exists" do
-        @mods_pname1.plain_name.first.display_value.should == @disp_form
+        expect(@mods_pname1.plain_name.first.display_value).to eq(@disp_form)
         x = "<mods><name type='personal'>
               	  <namePart>Alterman, Eric</namePart>
               	  <displayForm>Eric Alterman</displayForm>
               </name><mods>"
         r = Mods::Record.new.from_str(x, false)         
-        r.plain_name.first.display_value.should == 'Eric Alterman'
+        expect(r.plain_name.first.display_value).to eq('Eric Alterman')
       end
       it "display_value should not include <namePart type='date'>" do
-        @mods_namepart_date.plain_name.first.display_value.should == 'Suzy'
+        expect(@mods_namepart_date.plain_name.first.display_value).to eq('Suzy')
       end
       it "date text should be added to display_value_w_date when it is available" do
-        @mods_namepart_date.plain_name.first.display_value_w_date.should == 'Suzy, 1920-'
+        expect(@mods_namepart_date.plain_name.first.display_value_w_date).to eq('Suzy, 1920-')
       end
       it "date text should not be added to display_value_w_dates if dates are already included" do
         x = "<mods><name>
@@ -469,7 +469,7 @@ describe "Mods <name> Element" do
                   <displayForm>Woolf, Virginia, 1882-1941</namePart>
               </name></mods>"
         r = Mods::Record.new.from_str(x, false) 
-        r.plain_name.first.display_value_w_date.should == 'Woolf, Virginia, 1882-1941'
+        expect(r.plain_name.first.display_value_w_date).to eq('Woolf, Virginia, 1882-1941')
       end
       context "personal names" do
         before(:all) do
@@ -498,20 +498,20 @@ describe "Mods <name> Element" do
                   <namePart type='family'>Huston</namePart>
              </name></mods>"
           r = Mods::Record.new.from_str(x, false)
-          r.personal_name.first.display_value.should == 'Huston, John'
-          @pope.personal_name.first.display_value.should == 'John Paul II, Pope'
+          expect(r.personal_name.first.display_value).to eq('Huston, John')
+          expect(@pope.personal_name.first.display_value).to eq('John Paul II, Pope')
         end
         it "should be concatenation of untyped <namePart> elements if there is no family or given name" do
-          @pname2.personal_name.first.display_value.should == 'Crusty The Clown'
+          expect(@pname2.personal_name.first.display_value).to eq('Crusty The Clown')
         end
         it "should include <termOfAddress> elements, in order, comma separated" do
-          @pope.personal_name.first.display_value.should == 'John Paul II, Pope'
+          expect(@pope.personal_name.first.display_value).to eq('John Paul II, Pope')
         end
         it "display_value should not include date" do
-          @pope.personal_name.first.display_value.should_not =~ Regexp.new(@d)
+          expect(@pope.personal_name.first.display_value).not_to match(Regexp.new(@d))
         end
         it "date should be included in display_value_w_date" do
-          @pope.personal_name.first.display_value_w_date.should == "John Paul II, Pope, #{@d}"
+          expect(@pope.personal_name.first.display_value_w_date).to eq("John Paul II, Pope, #{@d}")
         end
       end
       context "not personal name (e.g. corporate)" do
@@ -521,7 +521,7 @@ describe "Mods <name> Element" do
             	<namePart>Court of Appeals (2nd Circuit)</namePart>
           </name></mods>"
           r = Mods::Record.new.from_str(x, false)
-          r.corporate_name.first.display_value.should == 'United States Court of Appeals (2nd Circuit)'
+          expect(r.corporate_name.first.display_value).to eq('United States Court of Appeals (2nd Circuit)')
         end
       end
     end # WITHOUT namespaces
@@ -561,36 +561,36 @@ describe "Mods <name> Element" do
       end  
       context "value" do
         it "should be the value of a text roleTerm" do
-          @mods_w_text.plain_name.role.value.should == ["Actor"]
+          expect(@mods_w_text.plain_name.role.value).to eq(["Actor"])
         end  
         it "should be the translation of the code if it is a marcrelator code and there is no text roleTerm" do
-          @mods_w_code.plain_name.role.value.should == ["Director"]
+          expect(@mods_w_code.plain_name.role.value).to eq(["Director"])
         end
         it "should be the value of the text roleTerm if there are both a code and a text roleTerm" do
-          @mods_w_both.plain_name.role.value.should == ["CreatorFake"]
+          expect(@mods_w_both.plain_name.role.value).to eq(["CreatorFake"])
         end
         it "should have 2 values if there are 2 role elements" do
-          @mods_mult_roles.plain_name.role.value.should == ['Creator', 'Performer']
+          expect(@mods_mult_roles.plain_name.role.value).to eq(['Creator', 'Performer'])
         end
       end
       context "authority" do
         it "should be empty if it is missing from xml" do
-          @mods_wo_authority.plain_name.role.authority.size.should == 0
+          expect(@mods_wo_authority.plain_name.role.authority.size).to eq(0)
         end
         it "should be the value of the authority attribute on the roleTerm element" do
-          @mods_w_code.plain_name.role.authority.should == ["marcrelator"]
-          @mods_w_text.plain_name.role.authority.should == ["marcrelator"]
-          @mods_w_both.plain_name.role.authority.should == ["marcrelator"]
+          expect(@mods_w_code.plain_name.role.authority).to eq(["marcrelator"])
+          expect(@mods_w_text.plain_name.role.authority).to eq(["marcrelator"])
+          expect(@mods_w_both.plain_name.role.authority).to eq(["marcrelator"])
         end
       end
       context "code" do
         it "should be empty if the roleTerm is not of type code" do
-          @mods_w_text.plain_name.role.code.size.should == 0
-          @mods_wo_authority.plain_name.role.code.size.should == 0
+          expect(@mods_w_text.plain_name.role.code.size).to eq(0)
+          expect(@mods_wo_authority.plain_name.role.code.size).to eq(0)
         end
         it "should be the value of the roleTerm element if element's type attribute is 'code'" do
-          @mods_w_code.plain_name.role.code.should == ["drt"]
-          @mods_w_both.plain_name.role.code.should == ["cre"]
+          expect(@mods_w_code.plain_name.role.code).to eq(["drt"])
+          expect(@mods_w_both.plain_name.role.code).to eq(["cre"])
         end
       end
       context "pertaining to a specific name" do
@@ -620,34 +620,34 @@ describe "Mods <name> Element" do
         end
         it "roles should be empty array when there is no role element" do
           @mods_rec.from_str(@mods_w_pers_name_ns)
-          @mods_rec.personal_name.first.role.size.should == 0
+          expect(@mods_rec.personal_name.first.role.size).to eq(0)
         end
         it "object should have same number of roles as it has role nodes in xml" do
-          @mods_complex.plain_name[0].role.size.should == 1
-          @mods_complex.plain_name[1].role.size.should == 2
-          @mods_complex.plain_name[2].role.size.should == 1
+          expect(@mods_complex.plain_name[0].role.size).to eq(1)
+          expect(@mods_complex.plain_name[1].role.size).to eq(2)
+          expect(@mods_complex.plain_name[2].role.size).to eq(1)
         end
         context "name's roles should be correctly populated" do
           it "text attribute" do
-            @mods_complex.plain_name[0].role.value.should == ['Director']
-            @mods_complex.plain_name[1].role.value.should == ['CreatorFake', 'Actor']
-            @mods_complex.plain_name[2].role.value.should == ['Actor']
+            expect(@mods_complex.plain_name[0].role.value).to eq(['Director'])
+            expect(@mods_complex.plain_name[1].role.value).to eq(['CreatorFake', 'Actor'])
+            expect(@mods_complex.plain_name[2].role.value).to eq(['Actor'])
           end
           it "code attribute" do
-            @mods_complex.plain_name[0].role.code.should == ['drt']
-            @mods_complex.plain_name[1].role.code.should == ['cre']
-            @mods_complex.plain_name[2].role.code.should == ['cre']
+            expect(@mods_complex.plain_name[0].role.code).to eq(['drt'])
+            expect(@mods_complex.plain_name[1].role.code).to eq(['cre'])
+            expect(@mods_complex.plain_name[2].role.code).to eq(['cre'])
           end
           it "authority attribute" do
-            @mods_complex.plain_name[0].role.authority.should == ['marcrelator']
-            @mods_complex.plain_name[1].role.authority.should == ['marcrelator', 'marcrelator']
-            @mods_complex.plain_name[2].role.authority.should == ['marcrelator']
+            expect(@mods_complex.plain_name[0].role.authority).to eq(['marcrelator'])
+            expect(@mods_complex.plain_name[1].role.authority).to eq(['marcrelator', 'marcrelator'])
+            expect(@mods_complex.plain_name[2].role.authority).to eq(['marcrelator'])
           end
           it "multiple roles" do
-            @mods_mult_roles.plain_name.first.role.value.should == ['Creator', 'Performer']
-            @mods_mult_roles.plain_name.first.role.code.should == ['cre']
-            @mods_mult_roles.plain_name.role.first.roleTerm.authority.first.should == 'marcrelator'
-            @mods_mult_roles.plain_name.role.last.roleTerm.authority.size.should == 0
+            expect(@mods_mult_roles.plain_name.first.role.value).to eq(['Creator', 'Performer'])
+            expect(@mods_mult_roles.plain_name.first.role.code).to eq(['cre'])
+            expect(@mods_mult_roles.plain_name.role.first.roleTerm.authority.first).to eq('marcrelator')
+            expect(@mods_mult_roles.plain_name.role.last.roleTerm.authority.size).to eq(0)
           end      
         end
       end # pertaining to a specific name
@@ -663,36 +663,36 @@ describe "Mods <name> Element" do
       end
       context "value" do
         it "should be the value of a text roleTerm" do
-          @mods_w_text.plain_name.role.value.should == ["Actor"]
+          expect(@mods_w_text.plain_name.role.value).to eq(["Actor"])
         end  
         it "should be the translation of the code if it is a marcrelator code and there is no text roleTerm" do
-          @mods_w_code.plain_name.role.value.should == ["Director"]
+          expect(@mods_w_code.plain_name.role.value).to eq(["Director"])
         end
         it "should be the value of the text roleTerm if there are both a code and a text roleTerm" do
-          @mods_w_both.plain_name.role.value.should == ["CreatorFake"]
+          expect(@mods_w_both.plain_name.role.value).to eq(["CreatorFake"])
         end
         it "should have 2 values if there are 2 role elements" do
-          @mods_mult_roles.plain_name.role.value.should == ['Creator', 'Performer']
+          expect(@mods_mult_roles.plain_name.role.value).to eq(['Creator', 'Performer'])
         end
       end
       context "authority" do
         it "should be empty if it is missing from xml" do
-          @mods_wo_authority.plain_name.role.authority.size.should == 0
+          expect(@mods_wo_authority.plain_name.role.authority.size).to eq(0)
         end
         it "should be the value of the authority attribute on the roleTerm element" do
-          @mods_w_code.plain_name.role.authority.should == ["marcrelator"]
-          @mods_w_text.plain_name.role.authority.should == ["marcrelator"]
-          @mods_w_both.plain_name.role.authority.should == ["marcrelator"]
+          expect(@mods_w_code.plain_name.role.authority).to eq(["marcrelator"])
+          expect(@mods_w_text.plain_name.role.authority).to eq(["marcrelator"])
+          expect(@mods_w_both.plain_name.role.authority).to eq(["marcrelator"])
         end
       end
       context "code" do
         it "should be empty if the roleTerm is not of type code" do
-          @mods_w_text.plain_name.role.code.size.should == 0
-          @mods_wo_authority.plain_name.role.code.size.should == 0
+          expect(@mods_w_text.plain_name.role.code.size).to eq(0)
+          expect(@mods_wo_authority.plain_name.role.code.size).to eq(0)
         end
         it "should be the value of the roleTerm element if element's type attribute is 'code'" do
-          @mods_w_code.plain_name.role.code.should == ["drt"]
-          @mods_w_both.plain_name.role.code.should == ["cre"]
+          expect(@mods_w_code.plain_name.role.code).to eq(["drt"])
+          expect(@mods_w_both.plain_name.role.code).to eq(["cre"])
         end
       end
       context "pertaining to a specific name" do
@@ -722,34 +722,34 @@ describe "Mods <name> Element" do
         end
         it "roles should be empty array when there is no role element" do
           @mods_rec.from_str(@mods_w_pers_name_ns)
-          @mods_rec.personal_name.first.role.size.should == 0
+          expect(@mods_rec.personal_name.first.role.size).to eq(0)
         end
         it "object should have same number of roles as it has role nodes in xml" do
-          @mods_complex.plain_name[0].role.size.should == 1
-          @mods_complex.plain_name[1].role.size.should == 2
-          @mods_complex.plain_name[2].role.size.should == 1
+          expect(@mods_complex.plain_name[0].role.size).to eq(1)
+          expect(@mods_complex.plain_name[1].role.size).to eq(2)
+          expect(@mods_complex.plain_name[2].role.size).to eq(1)
         end
         context "name's roles should be correctly populated" do
           it "text attribute" do
-            @mods_complex.plain_name[0].role.value.should == ['Director']
-            @mods_complex.plain_name[1].role.value.should == ['CreatorFake', 'Actor']
-            @mods_complex.plain_name[2].role.value.should == ['Actor']
+            expect(@mods_complex.plain_name[0].role.value).to eq(['Director'])
+            expect(@mods_complex.plain_name[1].role.value).to eq(['CreatorFake', 'Actor'])
+            expect(@mods_complex.plain_name[2].role.value).to eq(['Actor'])
           end
           it "code attribute" do
-            @mods_complex.plain_name[0].role.code.should == ['drt']
-            @mods_complex.plain_name[1].role.code.should == ['cre']
-            @mods_complex.plain_name[2].role.code.should == ['cre']
+            expect(@mods_complex.plain_name[0].role.code).to eq(['drt'])
+            expect(@mods_complex.plain_name[1].role.code).to eq(['cre'])
+            expect(@mods_complex.plain_name[2].role.code).to eq(['cre'])
           end
           it "authority attribute" do
-            @mods_complex.plain_name[0].role.authority.should == ['marcrelator']
-            @mods_complex.plain_name[1].role.authority.should == ['marcrelator', 'marcrelator']
-            @mods_complex.plain_name[2].role.authority.should == ['marcrelator']
+            expect(@mods_complex.plain_name[0].role.authority).to eq(['marcrelator'])
+            expect(@mods_complex.plain_name[1].role.authority).to eq(['marcrelator', 'marcrelator'])
+            expect(@mods_complex.plain_name[2].role.authority).to eq(['marcrelator'])
           end
           it "multiple roles" do
-            @mods_mult_roles.plain_name.first.role.value.should == ['Creator', 'Performer']
-            @mods_mult_roles.plain_name.first.role.code.should == ['cre']
-            @mods_mult_roles.plain_name.role.first.roleTerm.authority.first.should == 'marcrelator'
-            @mods_mult_roles.plain_name.role.last.roleTerm.authority.size.should == 0
+            expect(@mods_mult_roles.plain_name.first.role.value).to eq(['Creator', 'Performer'])
+            expect(@mods_mult_roles.plain_name.first.role.code).to eq(['cre'])
+            expect(@mods_mult_roles.plain_name.role.first.roleTerm.authority.first).to eq('marcrelator')
+            expect(@mods_mult_roles.plain_name.role.last.roleTerm.authority.size).to eq(0)
           end      
         end
       end # pertaining to a specific name