mods_display 0.3.3 → 0.3.4

data/spec/fields/language_spec.rb

@@ -1,35 +1,51 @@
-require "spec_helper"
+require 'spec_helper'
 
 def mods_display_language(mods_record)
-  ModsDisplay::Language.new(mods_record, ModsDisplay::Configuration::Base.new, double("controller"))
+  ModsDisplay::Language.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
 end
 
 describe ModsDisplay::Language do
   before(:all) do
-    @language = Stanford::Mods::Record.new.from_str("<mods><language><languageTerm type='code'>eng</languageTerm></language></mods>", false).language
-    @display_label = Stanford::Mods::Record.new.from_str("<mods><language displayLabel='Lang'><languageTerm type='code'>eng</languageTerm></language></mods>", false).language
-    @no_lang = Stanford::Mods::Record.new.from_str("<mods><language displayLabel='Lang'><languageTerm type='code'>zzzxxx</languageTerm></language></mods>", false).language
-    @mixed = Stanford::Mods::Record.new.from_str("<mods><language><languageTerm type='text'>ger</languageTerm><languageTerm type='code'>eng</languageTerm></language></mods>", false).language
-    @multi = Stanford::Mods::Record.new.from_str("<mods><language><languageTerm type='code'>ger</languageTerm><languageTerm type='code'>eng</languageTerm></language></mods>", false).language
-    @display_form = Stanford::Mods::Record.new.from_str("<mods><language><languageTerm>zzzxxx</languageTerm><displayForm>Klingon</displayForm></language></mods>", false).language
+    @language = Stanford::Mods::Record.new.from_str(
+      "<mods><language><languageTerm type='code'>eng</languageTerm></language></mods>", false
+    ).language
+    @display_label = Stanford::Mods::Record.new.from_str(
+      "<mods><language displayLabel='Lang'><languageTerm type='code'>eng</languageTerm></language></mods>", false
+    ).language
+    @no_lang = Stanford::Mods::Record.new.from_str(
+      "<mods><language displayLabel='Lang'><languageTerm type='code'>zzzxxx</languageTerm></language></mods>", false
+    ).language
+    @mixed = Stanford::Mods::Record.new.from_str(
+      "<mods>
+        <language><languageTerm type='text'>ger</languageTerm><languageTerm type='code'>eng</languageTerm></language>
+      </mods>", false
+    ).language
+    @multi = Stanford::Mods::Record.new.from_str(
+      "<mods>
+        <language><languageTerm type='code'>ger</languageTerm><languageTerm type='code'>eng</languageTerm></language>
+      </mods>", false
+    ).language
+    @display_form = Stanford::Mods::Record.new.from_str(
+      '<mods><language><languageTerm>zzzxxx</languageTerm><displayForm>Klingon</displayForm></language></mods>', false
+    ).language
   end
-  describe "fields" do
-    it "should return an array with a label/values object" do
+  describe 'fields' do
+    it 'should return an array with a label/values object' do
       values = mods_display_language(@display_label).fields
-      values.length.should == 1
-      values.first.should be_a ModsDisplay::Values
-      values.first.label.should == "Lang:"
-      values.first.values.should == ["English"]
+      expect(values.length).to eq(1)
+      expect(values.first).to be_a ModsDisplay::Values
+      expect(values.first.label).to eq('Lang:')
+      expect(values.first.values).to eq(['English'])
     end
     it "should not return any non type='code' languageTerms from the XML" do
       values = mods_display_language(@mixed).fields
-      values.length.should == 1
-      values.first.values.should == ["English"]
+      expect(values.length).to eq(1)
+      expect(values.first.values).to eq(['English'])
     end
-    it "should handle multiple languages correctly" do
+    it 'should handle multiple languages correctly' do
       values = mods_display_language(@multi).fields
-      values.length.should == 1
-      values.first.values.should == ["German", "English"]
+      expect(values.length).to eq(1)
+      expect(values.first.values).to eq(%w(German English))
     end
   end
-end
+end

data/spec/fields/location_spec.rb

@@ -1,44 +1,60 @@
-require "spec_helper"
+require 'spec_helper'
 
 def mods_display_location(mods_record)
-  ModsDisplay::Location.new(mods_record, ModsDisplay::Configuration::Base.new, double("controller"))
+  ModsDisplay::Location.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
 end
 
 describe ModsDisplay::Note do
   before(:all) do
-    @location = Stanford::Mods::Record.new.from_str("<mods><location><physicalLocation>The Location</physicalLocation></location></mods>", false).location
-    @urls = Stanford::Mods::Record.new.from_str("<mods><location><url displayLabel='Stanford University Library'>http://library.stanford.edu</url></location><location displayLabel='PURL'><url>http://purl.stanford.edu</url></location></mods>", false).location
-    @display_label = Stanford::Mods::Record.new.from_str("<mods><location displayLabel='Special Label'><shelfLocation>On Shelf A</shelfLocation></location></mods>", false).location
-    @repository_label = Stanford::Mods::Record.new.from_str("<mods><location><physicalLocation type='repository'>Location Field</physicalLocation></location></mods>", false).location
+    @location = Stanford::Mods::Record.new.from_str(
+      '<mods><location><physicalLocation>The Location</physicalLocation></location></mods>', false
+    ).location
+    @urls = Stanford::Mods::Record.new.from_str(
+      "<mods>
+        <location>
+          <url displayLabel='Stanford University Library'>http://library.stanford.edu</url>
+        </location>
+        <location displayLabel='PURL'>
+          <url>http://purl.stanford.edu</url>
+        </location>
+      </mods>",
+      false
+    ).location
+    @display_label = Stanford::Mods::Record.new.from_str(
+      "<mods><location displayLabel='Special Label'><shelfLocation>On Shelf A</shelfLocation></location></mods>", false
+    ).location
+    @repository_label = Stanford::Mods::Record.new.from_str(
+      "<mods><location><physicalLocation type='repository'>Location Field</physicalLocation></location></mods>", false
+    ).location
   end
-  describe "label" do
-    it "should have a default label" do
-      mods_display_location(@location).fields.first.label.should == "Location:"
+  describe 'label' do
+    it 'should have a default label' do
+      expect(mods_display_location(@location).fields.first.label).to eq('Location:')
     end
-    it "should use the displayLabel attribute when one is available" do
-      mods_display_location(@display_label).fields.first.label.should == "Special Label:"
+    it 'should use the displayLabel attribute when one is available' do
+      expect(mods_display_location(@display_label).fields.first.label).to eq('Special Label:')
     end
-    it "should handle the URL labels correctly" do
-      mods_display_location(@urls).fields.map{|f| f.label}.should == ["Location:", "PURL:"]
+    it 'should handle the URL labels correctly' do
+      expect(mods_display_location(@urls).fields.map(&:label)).to eq(['Location:', 'PURL:'])
     end
-    it "should use get a label from a list of translations" do
-      mods_display_location(@repository_label).fields.first.label.should == "Repository:"
+    it 'should use get a label from a list of translations' do
+      expect(mods_display_location(@repository_label).fields.first.label).to eq('Repository:')
     end
-  end  
-  describe "fields" do
-    describe "URLs" do
-      it "should link and use the displayLabel as text" do
+  end
+  describe 'fields' do
+    describe 'URLs' do
+      it 'should link and use the displayLabel as text' do
         fields = mods_display_location(@urls).fields
-        fields.length.should == 2
-        field = fields.find{|f| f.label == "Location:"}
-        field.values.should == ["<a href='http://library.stanford.edu'>Stanford University Library</a>"]
+        expect(fields.length).to eq(2)
+        field = fields.find { |f| f.label == 'Location:' }
+        expect(field.values).to eq(["<a href='http://library.stanford.edu'>Stanford University Library</a>"])
       end
-      it "should link the URL itself in the absence of a displayLabel on the url element" do
+      it 'should link the URL itself in the absence of a displayLabel on the url element' do
         fields = mods_display_location(@urls).fields
-        fields.length.should == 2
-        field = fields.find{|f| f.label == "PURL:"}
-        field.values.should == ["<a href='http://purl.stanford.edu'>http://purl.stanford.edu</a>"]
+        expect(fields.length).to eq(2)
+        field = fields.find { |f| f.label == 'PURL:' }
+        expect(field.values).to eq(["<a href='http://purl.stanford.edu'>http://purl.stanford.edu</a>"])
       end
     end
   end
-end
+end

data/spec/fields/name_spec.rb

@@ -1,5 +1,5 @@
-require "spec_helper"
-require "fixtures/name_fixtures"
+require 'spec_helper'
+require 'fixtures/name_fixtures'
 include NameFixtures
 
 def mods_display_name_link(mods_record)
@@ -10,140 +10,140 @@ def mods_display_name_link(mods_record)
 end
 
 def mods_display_name(mods_record)
-  ModsDisplay::Name.new(mods_record, ModsDisplay::Configuration::Base.new, double("controller"))
+  ModsDisplay::Name.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
 end
 
 describe ModsDisplay::Language do
+  include NameFixtures
   before(:all) do
-    @name = Stanford::Mods::Record.new.from_str("<mods><name><namePart>John Doe</namePart></name></mods>", false).plain_name
-    @blank_name = Stanford::Mods::Record.new.from_str("<mods><name><namePart/><role><roleTerm></roleTerm></role></name></mods>", false).plain_name
-    @primary_name = Stanford::Mods::Record.new.from_str("<mods><name usage='primary'><namePart>John Doe</namePart><role><roleTerm>lithographer</roleTerm></role></name></mods>", false).plain_name
-    @contributor = Stanford::Mods::Record.new.from_str("<mods><name><namePart>John Doe</namePart><role><roleTerm>lithographer</roleTerm></role></name></mods>", false).plain_name
-    @encoded_role = Stanford::Mods::Record.new.from_str("<mods><name><namePart>John Doe</namePart><role><roleTerm type='code' authority='marcrelator'>ltg</roleTerm></role></name></mods>", false).plain_name
-    @mixed_role = Stanford::Mods::Record.new.from_str("<mods><name><role><roleTerm>publisher</roleTerm></role><namePart>John Doe</namePart><role><roleTerm type='text' authority='marcrelator'>engraver</roleTerm></role></name></mods>", false).plain_name
-    @numeral_toa = Stanford::Mods::Record.new.from_str("<mods><name><namePart>Unqualfieid</namePart><namePart type='termsOfAddress'>XVII, ToA</namePart><namePart type='date'>date1-date2</namePart><namePart type='given'>Given Name</namePart><namePart type='family'>Family Name</namePart></name></mods>", false).plain_name
-    @simple_toa = Stanford::Mods::Record.new.from_str("<mods><name><namePart>Unqualfieid</namePart><namePart type='termsOfAddress'>Ier, empereur</namePart><namePart type='date'>date1-date2</namePart><namePart type='given'>Given Name</namePart><namePart type='family'>Family Name</namePart></name></mods>", false).plain_name
-    @display_form = Stanford::Mods::Record.new.from_str("<mods><name><namePart>John Doe</namePart><displayForm>Mr. John Doe</displayForm></name></mods>", false).plain_name
-    @collapse_label = Stanford::Mods::Record.new.from_str("<mods><name><namePart>John Doe</namePart></name><name><namePart>Jane Doe</namePart></name></mods>", false).plain_name
-    @complex_labels = Stanford::Mods::Record.new.from_str("<mods><name><namePart>John Doe</namePart></name><name><namePart>Jane Doe</namePart><role><roleTerm>lithographer</roleTerm></role></name><name><namePart>John Dough</namePart></name><name><namePart>Jane Dough</namePart></name></mods>", false).plain_name
-    @complex_roles = Stanford::Mods::Record.new.from_str("<mods><name><namePart>John Doe</namePart><role><roleTerm type='text'>Depicted</roleTerm><roleTerm type='code'>dpt</roleTerm></role></name></mods>", false).plain_name
-    @name_with_role = Stanford::Mods::Record.new.from_str("<mods><name><namePart>John Doe</namePart><role><roleTerm type='text'>Depicted</roleTerm></role></name></mods>", false).plain_name
-    @multiple_roles = Stanford::Mods::Record.new.from_str("<mods><name><namePart>John Doe</namePart><role><roleTerm type='text'>Depicted</roleTerm></role><role><roleTerm type='text'>Artist</roleTerm></role></name></mods>", false).plain_name
+    @name = Stanford::Mods::Record.new.from_str(simple_name_fixture, false).plain_name
+    @blank_name = Stanford::Mods::Record.new.from_str(blank_name_fixture, false).plain_name
+    @primary_name = Stanford::Mods::Record.new.from_str(primary_name_fixture, false).plain_name
+    @contributor = Stanford::Mods::Record.new.from_str(contributor_fixture, false).plain_name
+    @encoded_role = Stanford::Mods::Record.new.from_str(encoded_role_fixture, false).plain_name
+    @mixed_role = Stanford::Mods::Record.new.from_str(mixed_role_fixture, false).plain_name
+    @numeral_toa = Stanford::Mods::Record.new.from_str(numural_toa_fixture, false).plain_name
+    @simple_toa = Stanford::Mods::Record.new.from_str(simple_toa_fixture, false).plain_name
+    @display_form = Stanford::Mods::Record.new.from_str(display_form_name_fixture, false).plain_name
+    @collapse_label = Stanford::Mods::Record.new.from_str(collapse_label_name_fixture, false).plain_name
+    @complex_labels = Stanford::Mods::Record.new.from_str(complex_name_label_fixture, false).plain_name
+    @complex_roles = Stanford::Mods::Record.new.from_str(complex_role_name_fixture, false).plain_name
+    @name_with_role = Stanford::Mods::Record.new.from_str(name_with_role_fixture, false).plain_name
+    @multiple_roles = Stanford::Mods::Record.new.from_str(multiple_roles_fixture, false).plain_name
   end
-  describe "label" do
-    it "should default Author/Creator when no role is available" do
-      mods_display_name(@name).fields.first.label.should == "Author/Creator:"
+  describe 'label' do
+    it 'should default Author/Creator when no role is available' do
+      expect(mods_display_name(@name).fields.first.label).to eq('Author/Creator:')
     end
     it "should label 'Author/Creator' for primary authors" do
-      mods_display_name(@primary_name).fields.first.label.should == "Author/Creator:"
+      expect(mods_display_name(@primary_name).fields.first.label).to eq('Author/Creator:')
     end
-    it "should apply contributor labeling to all non blank/author/creator roles" do
-      mods_display_name(@contributor).fields.first.label.should == "Contributor:"
+    it 'should apply contributor labeling to all non blank/author/creator roles' do
+      expect(mods_display_name(@contributor).fields.first.label).to eq('Contributor:')
     end
   end
-  
-  describe "fields" do
-    it "should use the display form when available" do
+
+  describe 'fields' do
+    it 'should use the display form when available' do
       fields = mods_display_name(@display_form).fields
-      fields.length.should == 1
-      fields.first.values.length.should == 1
-      fields.first.values.first.should be_a(ModsDisplay::Name::Person)
-      fields.first.values.first.name.should == "Mr. John Doe"
+      expect(fields.length).to eq(1)
+      expect(fields.first.values.length).to eq(1)
+      expect(fields.first.values.first).to be_a(ModsDisplay::Name::Person)
+      expect(fields.first.values.first.name).to eq('Mr. John Doe')
     end
-    it "should not add blank names" do
-      mods_display_name(@blank_name).fields.should == []
+    it 'should not add blank names' do
+      expect(mods_display_name(@blank_name).fields).to eq([])
     end
-    it "should not delimit given name and termsOfAddress (that begin w/ roman numerals) with a comma" do
+    it 'should not delimit given name and termsOfAddress (that begin w/ roman numerals) with a comma' do
       fields = mods_display_name(@numeral_toa).fields
-      fields.length.should == 1
-      fields.first.values.length.should == 1
-      fields.first.values.first.to_s.should_not match /Given Name, XVII/
-      fields.first.values.first.to_s.should match /Given Name XVII/
+      expect(fields.length).to eq(1)
+      expect(fields.first.values.length).to eq(1)
+      expect(fields.first.values.first.to_s).not_to match(/Given Name, XVII/)
+      expect(fields.first.values.first.to_s).to match(/Given Name XVII/)
     end
-    it "should delimit given name and termsOfAddress (that DO NOT begin w/ roman numerals) with a comma" do
+    it 'should delimit given name and termsOfAddress (that DO NOT begin w/ roman numerals) with a comma' do
       fields = mods_display_name(@simple_toa).fields
-      fields.length.should == 1
-      fields.first.values.length.should == 1
-      fields.first.values.first.to_s.should match /Given Name, Ier, empereur/
-      fields.first.values.first.to_s.should_not match /Given Name Ier, empereur/
+      expect(fields.length).to eq(1)
+      expect(fields.first.values.length).to eq(1)
+      expect(fields.first.values.first.to_s).to match(/Given Name, Ier, empereur/)
+      expect(fields.first.values.first.to_s).not_to match(/Given Name Ier, empereur/)
     end
-    it "should collapse adjacent matching labels" do
+    it 'should collapse adjacent matching labels' do
       fields = mods_display_name(@collapse_label).fields
-      fields.length.should == 1
-      fields.first.label.should == "Author/Creator:"
+      expect(fields.length).to eq(1)
+      expect(fields.first.label).to eq('Author/Creator:')
       fields.first.values.each do |val|
-        ["John Doe", "Jane Doe"].should include val.to_s
+        expect(['John Doe', 'Jane Doe']).to include val.to_s
       end
     end
-    it "should perseve order and separation of non-adjesent matching labels" do
+    it 'should perseve order and separation of non-adjesent matching labels' do
       fields = mods_display_name(@complex_labels).fields
 
-      fields.length.should == 3
-      fields.first.label.should == "Author/Creator:"
-      fields.first.values.length.should == 1
-      fields.first.values.first.to_s.should == "John Doe"
-      
-      fields[1].label.should == "Contributor:"
-      fields[1].values.length.should == 1
-      fields[1].values.first.name.should == "Jane Doe"
-      fields[1].values.first.roles.should == ["lithographer"]
+      expect(fields.length).to eq(3)
+      expect(fields.first.label).to eq('Author/Creator:')
+      expect(fields.first.values.length).to eq(1)
+      expect(fields.first.values.first.to_s).to eq('John Doe')
+
+      expect(fields[1].label).to eq('Contributor:')
+      expect(fields[1].values.length).to eq(1)
+      expect(fields[1].values.first.name).to eq('Jane Doe')
+      expect(fields[1].values.first.roles).to eq(['lithographer'])
 
-      fields.last.label.should == "Author/Creator:"
-      fields.last.values.length.should == 2
+      expect(fields.last.label).to eq('Author/Creator:')
+      expect(fields.last.values.length).to eq(2)
       fields.last.values.each do |val|
-        ["Jane Dough", "John Dough"].should include val.to_s
+        expect(['Jane Dough', 'John Dough']).to include val.to_s
       end
     end
-    describe "roles" do
-      it "should get the role when present" do
+    describe 'roles' do
+      it 'should get the role when present' do
         fields = mods_display_name(@name_with_role).fields
-        fields.length.should == 1
-        fields.first.values.length.should == 1
-        fields.first.values.first.should be_a(ModsDisplay::Name::Person)
-        fields.first.values.first.roles.should == ["Depicted"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values.length).to eq(1)
+        expect(fields.first.values.first).to be_a(ModsDisplay::Name::Person)
+        expect(fields.first.values.first.roles).to eq(['Depicted'])
       end
-      it "should decode encoded roleTerms when no text (or non-typed) roleTerm is available" do
+      it 'should decode encoded roleTerms when no text (or non-typed) roleTerm is available' do
         fields = mods_display_name(@encoded_role).fields
-        fields.length.should == 1
-        fields.first.values.length.should == 1
-        fields.first.values.first.to_s.should == "John Doe (Lithographer)"
+        expect(fields.length).to eq(1)
+        expect(fields.first.values.length).to eq(1)
+        expect(fields.first.values.first.to_s).to eq('John Doe (Lithographer)')
       end
       it "should get the type='text' role before an untyped role" do
         fields = mods_display_name(@mixed_role).fields
-        fields.length.should == 1
-        fields.first.values.length.should == 1
-        fields.first.values.first.roles.should == ["engraver"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values.length).to eq(1)
+        expect(fields.first.values.first.roles).to eq(['engraver'])
       end
-      it "should be handled correctly when there are more than one" do
+      it 'should be handled correctly when there are more than one' do
         fields = mods_display_name(@multiple_roles).fields
-        fields.length.should == 1
-        fields.first.values.length.should == 1
-        fields.first.values.first.roles.should == ["Depicted", "Artist"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values.length).to eq(1)
+        expect(fields.first.values.first.roles).to eq(%w(Depicted Artist))
       end
-      it "should handle code and text roleTerms together correctly" do
+      it 'should handle code and text roleTerms together correctly' do
         fields = mods_display_name(@complex_roles).fields
-        fields.length.should == 1
-        fields.first.values.length.should == 1
-        fields.first.values.first.roles.should == ["Depicted"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values.length).to eq(1)
+        expect(fields.first.values.first.roles).to eq(['Depicted'])
       end
-      it "should comma seperate multiple roles" do
+      it 'should comma seperate multiple roles' do
         fields = mods_display_name(@multiple_roles).fields
-        fields.length.should == 1
-        fields.first.values.length.should == 1
-        fields.first.values.first.to_s.should == "John Doe (Depicted, Artist)"
+        expect(fields.length).to eq(1)
+        expect(fields.first.values.length).to eq(1)
+        expect(fields.first.values.first.to_s).to eq('John Doe (Depicted, Artist)')
       end
     end
   end
-  
-  describe "to_html" do
-    it "should add the role to the name in parens" do
+
+  describe 'to_html' do
+    it 'should add the role to the name in parens' do
       html = mods_display_name(@name_with_role).to_html
-      html.should match(/<dd>John Doe \(Depicted\)<\/dd>/)
+      expect(html).to match(%r{<dd>John Doe \(Depicted\)</dd>})
     end
-    it "should linke the name and not the role if requested" do
+    it 'should linke the name and not the role if requested' do
       html = mods_display_name_link(@name_with_role).to_html
-      html.should match(/<dd><a href='.*\?John Doe'>John Doe<\/a> \(Depicted\)<\/dd>/)
+      expect(html).to match(%r{<dd><a href='.*\?John Doe'>John Doe</a> \(Depicted\)</dd>})
     end
   end
-  
-end
+end

data/spec/fields/note_spec.rb

@@ -1,59 +1,72 @@
-require "spec_helper"
+require 'spec_helper'
 
 def mods_display_note(mods_record)
-  ModsDisplay::Note.new(mods_record, ModsDisplay::Configuration::Base.new, double("controller"))
+  ModsDisplay::Note.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
 end
 
 describe ModsDisplay::Note do
   before(:all) do
-    @note = Stanford::Mods::Record.new.from_str("<mods><note>Note Field</note></mods>", false).note
-    @display_label = Stanford::Mods::Record.new.from_str("<mods><note displayLabel='Special Label'>Note Field</note></mods>", false).note
-    @sor_label = Stanford::Mods::Record.new.from_str("<mods><note type='statement of responsibility'>Note Field</note></mods>", false).note
-    @contact_note = Stanford::Mods::Record.new.from_str("<mods><note type='contact'>jdoe@example.com</note><note>Note Field</note></mods>", false).note
-    @type_label = Stanford::Mods::Record.new.from_str("<mods><note type='some other Type'>Note Field</note></mods>", false).note
-    @complex_label = Stanford::Mods::Record.new.from_str("<mods><note>Note Field</note><note>2nd Note Field</note><note type='statement of responsibility'>SoR</note><note>Another Note</note></mods>", false).note
+    @note = Stanford::Mods::Record.new.from_str('<mods><note>Note Field</note></mods>', false).note
+    @display_label = Stanford::Mods::Record.new.from_str(
+      "<mods><note displayLabel='Special Label'>Note Field</note></mods>", false
+    ).note
+    @sor_label = Stanford::Mods::Record.new.from_str(
+      "<mods><note type='statement of responsibility'>Note Field</note></mods>", false
+    ).note
+    @contact_note = Stanford::Mods::Record.new.from_str(
+      "<mods><note type='contact'>jdoe@example.com</note><note>Note Field</note></mods>", false
+    ).note
+    @type_label = Stanford::Mods::Record.new.from_str(
+      "<mods><note type='some other Type'>Note Field</note></mods>", false
+    ).note
+    @complex_label = Stanford::Mods::Record.new.from_str(
+      "<mods>
+        <note>Note Field</note><note>2nd Note Field</note>
+        <note type='statement of responsibility'>SoR</note>
+        <note>Another Note</note>
+      </mods>", false
+    ).note
   end
-  describe "label" do
-    it "should have a default label" do
-      mods_display_note(@note).fields.first.label.should == "Note:"
+  describe 'label' do
+    it 'should have a default label' do
+      expect(mods_display_note(@note).fields.first.label).to eq('Note:')
     end
-    it "should use the displayLabel attribute when one is available" do
-      mods_display_note(@display_label).fields.first.label.should == "Special Label:"
+    it 'should use the displayLabel attribute when one is available' do
+      expect(mods_display_note(@display_label).fields.first.label).to eq('Special Label:')
     end
-    it "should use get a label from a list of translations" do
-      mods_display_note(@sor_label).fields.first.label.should == "Statement of responsibility:"
+    it 'should use get a label from a list of translations' do
+      expect(mods_display_note(@sor_label).fields.first.label).to eq('Statement of responsibility:')
     end
-    it "should use use the capitalized type attribute if one is present" do
-      mods_display_note(@type_label).fields.first.label.should == "Some other type:"
+    it 'should use use the capitalized type attribute if one is present' do
+      expect(mods_display_note(@type_label).fields.first.label).to eq('Some other type:')
     end
   end
-  
-  describe "fields" do
-    it "should handle single values" do
+
+  describe 'fields' do
+    it 'should handle single values' do
       fields = mods_display_note(@note).fields
-      fields.length.should == 1
-      fields.first.values.should == ["Note Field"]
+      expect(fields.length).to eq(1)
+      expect(fields.first.values).to eq(['Note Field'])
     end
-    it "should handle complex grouping" do
+    it 'should handle complex grouping' do
       fields = mods_display_note(@complex_label).fields
-      fields.length.should == 3
-      fields.first.label.should == "Note:"
-      fields.first.values.length == 2
-      fields.first.values.should == ["Note Field", "2nd Note Field"]
-      
-      fields[1].label == "Statement of responsibility"
-      fields[1].values.length == 1
-      fields[1].values.should == ["SoR"]
-      
-      fields.last.label.should == "Note:"
-      fields.last.values.length == 1
-      fields.last.values.should == ["Another Note"]
+      expect(fields.length).to eq(3)
+      expect(fields.first.label).to eq('Note:')
+      expect(fields.first.values.length).to eq 2
+      expect(fields.first.values).to eq(['Note Field', '2nd Note Field'])
+
+      expect(fields[1].label).to eq 'Statement of responsibility:'
+      expect(fields[1].values.length).to eq 1
+      expect(fields[1].values).to eq(['SoR'])
+
+      expect(fields.last.label).to eq('Note:')
+      expect(fields.last.values.length).to eq 1
+      expect(fields.last.values).to eq(['Another Note'])
     end
-    it "should not include any contact fields" do
+    it 'should not include any contact fields' do
       fields = mods_display_note(@contact_note).fields
-      fields.length.should == 1
-      fields.first.values.should == ["Note Field"]
+      expect(fields.length).to eq(1)
+      expect(fields.first.values).to eq(['Note Field'])
     end
   end
-  
-end
+end