mods_display 0.3.3 → 0.3.4

data/spec/fields/contact_spec.rb

@@ -1,21 +1,23 @@
-require "spec_helper"
+require 'spec_helper'
 
 def mods_display_contact(mods_record)
-  ModsDisplay::Contact.new(mods_record, ModsDisplay::Configuration::Base.new, double("controller"))
+  ModsDisplay::Contact.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
 end
 
 describe ModsDisplay::Contact do
   before(:all) do
-    @contact_note = Stanford::Mods::Record.new.from_str("<mods><note type='contact'>jdoe@example.com</note><note>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
   end
-  it "should only get contact fields" do
+  it 'should only get contact fields' do
     fields = mods_display_contact(@contact_note).fields
-    fields.length.should == 1
-    fields.first.values.should include("jdoe@example.com")
+    expect(fields.length).to eq(1)
+    expect(fields.first.values).to include('jdoe@example.com')
   end
-  it "should not get any non-contact fields" do
+  it 'should not get any non-contact fields' do
     fields = mods_display_contact(@contact_note).fields
-    fields.length.should == 1
-    fields.first.values.should_not include("Note Field")
+    expect(fields.length).to eq(1)
+    expect(fields.first.values).not_to include('Note Field')
   end
 end

data/spec/fields/contents_spec.rb

@@ -1,21 +1,24 @@
-require "spec_helper"
+require 'spec_helper'
 
 def mods_display_contents(mods_record)
-  ModsDisplay::Contents.new(mods_record, ModsDisplay::Configuration::Base.new, double("controller"))
+  ModsDisplay::Contents.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
 end
 
 describe ModsDisplay::Contents do
   before(:all) do
-    @contents = Stanford::Mods::Record.new.from_str("<mods><tableOfContents>Content Note</tableOfContents></mods>", false).tableOfContents
-    @display_label = Stanford::Mods::Record.new.from_str("<mods><tableOfContents displayLabel='Special Label'>Content Note</tableOfContents></mods>", false).tableOfContents
+    @contents = Stanford::Mods::Record.new.from_str(
+      '<mods><tableOfContents>Content Note</tableOfContents></mods>', false
+    ).tableOfContents
+    @display_label = Stanford::Mods::Record.new.from_str(
+      "<mods><tableOfContents displayLabel='Special Label'>Content Note</tableOfContents></mods>", false
+    ).tableOfContents
   end
-  describe "label" do
-    it "should have a default label" do
-      mods_display_contents(@contents).label.should == "Table of contents:"
+  describe 'label' do
+    it 'should have a default label' do
+      expect(mods_display_contents(@contents).label).to eq('Table of contents:')
     end
-    it "should use the displayLabel attribute when one is available" do
-      mods_display_contents(@display_label).label.should == "Special Label:"
+    it 'should use the displayLabel attribute when one is available' do
+      expect(mods_display_contents(@display_label).label).to eq('Special Label:')
     end
-  end  
-  
-end
+  end
+end

data/spec/fields/description_spec.rb

@@ -1,37 +1,55 @@
-require "spec_helper"
+require 'spec_helper'
 
 def mods_display_description(mods)
-  ModsDisplay::Description.new(mods, ModsDisplay::Configuration::Base.new, double("controller"))
+  ModsDisplay::Description.new(mods, ModsDisplay::Configuration::Base.new, double('controller'))
 end
 
 describe ModsDisplay::Description do
   before(:all) do
-    @form = Stanford::Mods::Record.new.from_str("<mods><physicalDescription><note>Description Note</note></physicalDescription></mods>", false).physical_description
-    @display_label = Stanford::Mods::Record.new.from_str("<mods><physicalDescription displayLabel='SpecialLabel'><note>Description Note</note></physicalDescription></mods>", false).physical_description
-    @child_display_label = Stanford::Mods::Record.new.from_str("<mods><physicalDescription><note displayLabel='Note Label'>Description Note</note></physicalDescription></mods>", false).physical_description
-    @mixed = Stanford::Mods::Record.new.from_str("<mods><physicalDescription><note>Description Note</note><digitalOrigin>Digital Origin Note</digitalOrigin></physicalDescription></mods>", false).physical_description
+    @form = Stanford::Mods::Record.new.from_str(
+      '<mods><physicalDescription><note>Description Note</note></physicalDescription></mods>', false
+    ).physical_description
+    @display_label = Stanford::Mods::Record.new.from_str(
+      "<mods>
+        <physicalDescription displayLabel='SpecialLabel'><note>Description Note</note></physicalDescription>
+       </mods>", false
+    ).physical_description
+    @child_display_label = Stanford::Mods::Record.new.from_str(
+      "<mods><physicalDescription><note displayLabel='Note Label'>Description Note</note></physicalDescription></mods>",
+      false
+    ).physical_description
+    @mixed = Stanford::Mods::Record.new.from_str(
+      '<mods>
+        <physicalDescription>
+          <note>Description Note</note>
+          <digitalOrigin>Digital Origin Note</digitalOrigin>
+        </physicalDescription>
+       </mods>', false
+    ).physical_description
   end
-  describe "labels" do
-    it "should use the displayLabel if one is provided" do
-      mods_display_description(@display_label).fields.first.label.should == "SpecialLabel:"
+  describe 'labels' do
+    it 'should use the displayLabel if one is provided' do
+      expect(mods_display_description(@display_label).fields.first.label).to eq('SpecialLabel:')
     end
-    it "should get the default label for a child element" do
-      mods_display_description(@form).fields.first.label.should == "Note:"
+    it 'should get the default label for a child element' do
+      expect(mods_display_description(@form).fields.first.label).to eq('Note:')
     end
-    it "should get multiple lables for mixed content" do
-      mods_display_description(@mixed).fields.map{|v| v.label }.should == ["Note:", "Digital origin:"]
+    it 'should get multiple lables for mixed content' do
+      expect(mods_display_description(@mixed).fields.map(&:label)).to eq(['Note:', 'Digital origin:'])
     end
-    it "should get the display label from child elements" do
-      mods_display_description(@child_display_label).fields.map{|f| f.label }.should == ["Note Label:"]
+    it 'should get the display label from child elements' do
+      expect(mods_display_description(@child_display_label).fields.map(&:label)).to eq(['Note Label:'])
     end
   end
-  
-  describe "fields" do
-    it "should get the value from a field in physicalDescription" do
-      mods_display_description(@form).fields.first.values.should == ["Description Note"]
+
+  describe 'fields' do
+    it 'should get the value from a field in physicalDescription' do
+      expect(mods_display_description(@form).fields.first.values).to eq(['Description Note'])
     end
-    it "should get multiple values for mixed content" do
-      mods_display_description(@mixed).fields.map{|v| v.values }.should == [["Description Note"], ["Digital Origin Note"]]
+    it 'should get multiple values for mixed content' do
+      expect(mods_display_description(@mixed).fields.map(&:values)).to eq(
+        [['Description Note'], ['Digital Origin Note']]
+      )
     end
   end
-end
+end

data/spec/fields/format_spec.rb

@@ -1,31 +1,41 @@
-require "spec_helper"
+require 'spec_helper'
 def mods_display_format(mods)
-  ModsDisplay::Format.new(mods, ModsDisplay::Configuration::Base.new, double("controller"))
+  ModsDisplay::Format.new(mods, ModsDisplay::Configuration::Base.new, double('controller'))
 end
 
 describe ModsDisplay::Format do
   before(:all) do
-    @format = Stanford::Mods::Record.new.from_str("<mods><typeOfResource>Format</typeOfResource></mods>", false).typeOfResource
-    @duplicate_forms = Stanford::Mods::Record.new.from_str("<mods><physicalDescription><form>Map</form><form>Map</form></physicalDescription></mods>", false)
-    @display_label = Stanford::Mods::Record.new.from_str("<mods><typeOfResource displayLabel='SpecialFormat'>Mixed Materials</typeOfResource></mods>", false).typeOfResource
-    @space_format = Stanford::Mods::Record.new.from_str("<mods><typeOfResource>Mixed Materials</typeOfResource></mods>", false).typeOfResource
-    @slash_format = Stanford::Mods::Record.new.from_str("<mods><typeOfResource>Manuscript/Archive</typeOfResource></mods>", false).typeOfResource
+    @format = Stanford::Mods::Record.new.from_str(
+      '<mods><typeOfResource>Format</typeOfResource></mods>', false
+    ).typeOfResource
+    @duplicate_forms = Stanford::Mods::Record.new.from_str(
+      '<mods><physicalDescription><form>Map</form><form>Map</form></physicalDescription></mods>', false
+    )
+    @display_label = Stanford::Mods::Record.new.from_str(
+      "<mods><typeOfResource displayLabel='SpecialFormat'>Mixed Materials</typeOfResource></mods>", false
+    ).typeOfResource
+    @space_format = Stanford::Mods::Record.new.from_str(
+      '<mods><typeOfResource>Mixed Materials</typeOfResource></mods>', false
+    ).typeOfResource
+    @slash_format = Stanford::Mods::Record.new.from_str(
+      '<mods><typeOfResource>Manuscript/Archive</typeOfResource></mods>', false
+    ).typeOfResource
   end
-  describe "format_class" do
-    it "should remove any spaces" do
-      ModsDisplay::Format.send(:format_class, "Mixed Materials").should == "mixed_materials"
+  describe 'format_class' do
+    it 'should remove any spaces' do
+      expect(ModsDisplay::Format.send(:format_class, 'Mixed Materials')).to eq('mixed_materials')
     end
-    it "should replace any slashes" do
-      ModsDisplay::Format.send(:format_class, "Manuscript/Archive").should == "manuscript_archive"
+    it 'should replace any slashes' do
+      expect(ModsDisplay::Format.send(:format_class, 'Manuscript/Archive')).to eq('manuscript_archive')
     end
   end
-  describe "fields" do
-    describe "form" do
-      it "should remove duplicate values" do
+  describe 'fields' do
+    describe 'form' do
+      it 'should remove duplicate values' do
         fields = mods_display_format(@duplicate_forms).fields
-        fields.length.should == 1
-        fields.first.values.should == ["Map"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values).to eq(['Map'])
       end
     end
   end
-end
+end

data/spec/fields/genre_spec.rb

@@ -1,32 +1,34 @@
-require "spec_helper"
+require 'spec_helper'
 
 def mods_display_genre(mods_record)
-  ModsDisplay::Genre.new(mods_record, ModsDisplay::Configuration::Base.new, double("controller"))
+  ModsDisplay::Genre.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
 end
 
 describe ModsDisplay::Abstract do
   before(:all) do
-    @genre = Stanford::Mods::Record.new.from_str("<mods><genre>Map Data</genre></mods>", false).genre
-    @downcase = Stanford::Mods::Record.new.from_str("<mods><genre>map data</genre></mods>", false).genre
-    @display_label = Stanford::Mods::Record.new.from_str("<mods><genre displayLabel='Special label'>Catographic</genre></mods>", false).genre
+    @genre = Stanford::Mods::Record.new.from_str('<mods><genre>Map Data</genre></mods>', false).genre
+    @downcase = Stanford::Mods::Record.new.from_str('<mods><genre>map data</genre></mods>', false).genre
+    @display_label = Stanford::Mods::Record.new.from_str(
+      "<mods><genre displayLabel='Special label'>Catographic</genre></mods>", false
+    ).genre
   end
-  describe "labels" do
+  describe 'labels' do
     it "should return a default 'Genre' label" do
       fields = mods_display_genre(@genre).fields
-      fields.length.should == 1
-      fields.first.label.should == "Genre:"
+      expect(fields.length).to eq(1)
+      expect(fields.first.label).to eq('Genre:')
     end
-    it "should use a display label when one is available" do
+    it 'should use a display label when one is available' do
       fields = mods_display_genre(@display_label).fields
-      fields.length.should == 1
-      fields.first.label.should == "Special label:"
+      expect(fields.length).to eq(1)
+      expect(fields.first.label).to eq('Special label:')
     end
   end
-  describe "fields" do
-    it "should capitalize the first letter in a genre" do
+  describe 'fields' do
+    it 'should capitalize the first letter in a genre' do
       fields = mods_display_genre(@downcase).fields
-      fields.length.should == 1
-      fields.first.values.should == ["Map data"]
+      expect(fields.length).to eq(1)
+      expect(fields.first.values).to eq(['Map data'])
     end
   end
-end
+end

data/spec/fields/identifier_spec.rb

@@ -1,49 +1,61 @@
-require "spec_helper"
+require 'spec_helper'
 
 def mods_display_id(mods_record)
-  ModsDisplay::Identifier.new(mods_record, ModsDisplay::Configuration::Base.new, double("controller"))
+  ModsDisplay::Identifier.new(mods_record, ModsDisplay::Configuration::Base.new, double('controller'))
 end
 
 describe ModsDisplay::Note do
   before(:all) do
-    @id = Stanford::Mods::Record.new.from_str("<mods><identifier>12345</identifier></mods>", false).identifier
-    @display_label = Stanford::Mods::Record.new.from_str("<mods><identifier displayLabel='Special Label'>54321</identifier></mods>", false).identifier
-    @issue_label = Stanford::Mods::Record.new.from_str("<mods><identifier type='issue number'>Issue 1</identifier></mods>", false).identifier
-    @type_label = Stanford::Mods::Record.new.from_str("<mods><identifier type='Some other Type'>98765</identifier></mods>", false).identifier
-    @complex_label = Stanford::Mods::Record.new.from_str("<mods><identifier>12345</identifier><identifier>54321</identifier><identifier type='issue number'>12345</identifier><identifier>98765</identifier></mods>", false).identifier
+    @id = Stanford::Mods::Record.new.from_str('<mods><identifier>12345</identifier></mods>', false).identifier
+    @display_label = Stanford::Mods::Record.new.from_str(
+      "<mods><identifier displayLabel='Special Label'>54321</identifier></mods>", false
+    ).identifier
+    @issue_label = Stanford::Mods::Record.new.from_str(
+      "<mods><identifier type='issue number'>Issue 1</identifier></mods>", false
+    ).identifier
+    @type_label = Stanford::Mods::Record.new.from_str(
+      "<mods><identifier type='Some other Type'>98765</identifier></mods>", false
+    ).identifier
+    @complex_label = Stanford::Mods::Record.new.from_str(
+      "<mods>
+        <identifier>12345</identifier>
+        <identifier>54321</identifier>
+        <identifier type='issue number'>12345</identifier>
+        <identifier>98765</identifier>
+      </mods>", false
+    ).identifier
   end
-  describe "label" do
-    it "should have a default label" do
-      mods_display_id(@id).fields.first.label.should == "Identifier:"
+  describe 'label' do
+    it 'should have a default label' do
+      expect(mods_display_id(@id).fields.first.label).to eq('Identifier:')
     end
-    it "should use the displayLabel attribute when one is available" do
-      mods_display_id(@display_label).fields.first.label.should == "Special Label:"
+    it 'should use the displayLabel attribute when one is available' do
+      expect(mods_display_id(@display_label).fields.first.label).to eq('Special Label:')
     end
-    it "should use get a label from a list of translations" do
-      mods_display_id(@issue_label).fields.first.label.should == "Issue number:"
+    it 'should use get a label from a list of translations' do
+      expect(mods_display_id(@issue_label).fields.first.label).to eq('Issue number:')
     end
-    it "should use use the raw type attribute if one is present" do
-      mods_display_id(@type_label).fields.first.label.should == "Some other Type:"
+    it 'should use use the raw type attribute if one is present' do
+      expect(mods_display_id(@type_label).fields.first.label).to eq('Some other Type:')
     end
   end
-  
-  describe "fields" do
-    it "should handle matching adjacent labels" do
+
+  describe 'fields' do
+    it 'should handle matching adjacent labels' do
       fields = mods_display_id(@complex_label).fields
-      fields.length.should == 3
-      
-      fields.first.label.should == "Identifier:"
-      fields.first.values.length.should == 2
-      fields.first.values.should == ["12345", "54321"]
-      
-      fields[1].label.should == "Issue number:"
-      fields[1].values.length.should == 1
-      fields[1].values.should == ["12345"]
-      
-      fields.last.label.should == "Identifier:"
-      fields.last.values.length.should == 1
-      fields.last.values.should == ["98765"]
+      expect(fields.length).to eq(3)
+
+      expect(fields.first.label).to eq('Identifier:')
+      expect(fields.first.values.length).to eq(2)
+      expect(fields.first.values).to eq(%w(12345 54321))
+
+      expect(fields[1].label).to eq('Issue number:')
+      expect(fields[1].values.length).to eq(1)
+      expect(fields[1].values).to eq(['12345'])
+
+      expect(fields.last.label).to eq('Identifier:')
+      expect(fields.last.values.length).to eq(1)
+      expect(fields.last.values).to eq(['98765'])
     end
   end
-  
-end
+end

data/spec/fields/imprint_spec.rb

@@ -1,13 +1,21 @@
-require "spec_helper"
-require "fixtures/imprint_fixtures"
+require 'spec_helper'
+require 'fixtures/imprint_fixtures'
 
 include ImprintFixtures
 
 def mods_display_imprint(mods_record)
-  ModsDisplay::Imprint.new(mods_record, ModsDisplay::Configuration::Imprint.new, double("controller"))
+  ModsDisplay::Imprint.new(mods_record, ModsDisplay::Configuration::Imprint.new, double('controller'))
 end
+
 def mods_display_format_date_imprint(mods_record)
-  ModsDisplay::Imprint.new(mods_record, ModsDisplay::Configuration::Imprint.new{full_date_format "(%Y) %B, %d"; short_date_format "%B (%Y)"}, double("controller"))
+  ModsDisplay::Imprint.new(
+    mods_record,
+    ModsDisplay::Configuration::Imprint.new do
+      full_date_format('(%Y) %B, %d')
+      short_date_format('%B (%Y)')
+    end,
+    double('controller')
+  )
 end
 
 describe ModsDisplay::Imprint do
@@ -37,209 +45,227 @@ describe ModsDisplay::Imprint do
     @encoded_dates = Stanford::Mods::Record.new.from_str(encoded_dates, false).origin_info
     @bad_dates = Stanford::Mods::Record.new.from_str(bad_dates, false).origin_info
     @invalid_dates = Stanford::Mods::Record.new.from_str(invalid_dates, false).origin_info
+    @punctuation_imprint = Stanford::Mods::Record.new.from_str(punctuation_imprint_fixture, false).origin_info
+    @bc_ad_dates = Stanford::Mods::Record.new.from_str(bc_ad_imprint_date_fixture, false).origin_info
   end
 
-  describe "labels" do
-    it "should get the Imprint label by default" do
-      mods_display_imprint(@imprint).fields.first.label.should == "Imprint:"
+  describe 'labels' do
+    it 'should get the Imprint label by default' do
+      expect(mods_display_imprint(@imprint).fields.first.label).to eq('Imprint:')
     end
-    it "should get the label from non-imprint origin info fields" do
+    it 'should get the label from non-imprint origin info fields' do
       fields = mods_display_imprint(@edition_and_date).fields
-      fields.first.label.should == "Date valid:"
-      fields.last.label.should == "Issuance:"
+      expect(fields.first.label).to eq('Date valid:')
+      expect(fields.last.label).to eq('Issuance:')
     end
-    it "should get multiple labels when we have mixed content" do
-      mods_display_imprint(@mixed).fields.map{|val| val.label }.should == ["Imprint:", "Date captured:", "Issuance:"]
+    it 'should get multiple labels when we have mixed content' do
+      expect(mods_display_imprint(@mixed).fields.map(&:label)).to eq(['Imprint:', 'Date captured:', 'Issuance:'])
     end
-    it "should use the displayLabel when available" do
-       mods_display_imprint(@display_label).fields.map{|val| val.label }.should == ["TheLabel:", "IssuanceLabel:"]
+    it 'should use the displayLabel when available' do
+      expect(mods_display_imprint(@display_label).fields.map(&:label)).to eq(['TheLabel:', 'IssuanceLabel:'])
     end
   end
 
-  describe "fields" do
-    it "should return various parts of the imprint" do
-      mods_display_imprint(@imprint).fields.map{|val| val.values }.join(" ").should == "An edition - A Place : A Publisher, An Issue Date, Another Date"
+  describe 'fields' do
+    it 'should return various parts of the imprint' do
+      expect(mods_display_imprint(@imprint).fields.map(&:values).join(' ')).to eq(
+        'An edition - A Place : A Publisher, An Issue Date, Another Date'
+      )
     end
-    it "should handle the punctuation when the edition is missing" do
-      values = mods_display_imprint(@no_edition).fields.map{|val| val.values }.join(" ")
-      values.strip.should_not match(/^-/)
-      values.should match(/^A Place/)
+    it 'should handle the punctuation when the edition is missing' do
+      values = mods_display_imprint(@no_edition).fields.map(&:values).join(' ')
+      expect(values.strip).not_to match(/^-/)
+      expect(values).to match(/^A Place/)
     end
-    it "should get the text for non-imprint origin info fields" do
+    it 'should get the text for non-imprint origin info fields' do
       fields = mods_display_imprint(@edition_and_date).fields
-      fields.first.values.should == ["A Valid Date"]
-      fields.last.values.should == ["The Issuance"]
+      expect(fields.first.values).to eq(['A Valid Date'])
+      expect(fields.last.values).to eq(['The Issuance'])
     end
-    it "should handle mixed mods properly" do
+    it 'should handle mixed mods properly' do
       values = mods_display_imprint(@mixed).fields
-      values.length.should == 3
-      values.map{|val| val.values}.should include(["A Place : A Publisher"])
-      values.map{|val| val.values}.should include(["The Issuance"])
-      values.map{|val| val.values}.should include(["The Capture Date"])
+      expect(values.length).to eq(3)
+      expect(values.map(&:values)).to include(['A Place : A Publisher'])
+      expect(values.map(&:values)).to include(['The Issuance'])
+      expect(values.map(&:values)).to include(['The Capture Date'])
     end
   end
-  describe "date processing" do
-    describe "ranges" do
+  describe 'date processing' do
+    describe 'ranges' do
       it "should join start and end point ranges with a '-'" do
         fields = mods_display_imprint(@date_range).fields
-        fields.length.should == 1
-        fields.first.values.should == ["1820-1825"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values).to eq(['1820-1825'])
       end
-      it "should handle open ranges properly" do
+      it 'should handle open ranges properly' do
         fields = mods_display_imprint(@open_date_range).fields
-        fields.length.should == 1
-        fields.first.values.should == ["1820-"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values).to eq(['1820-'])
       end
-      it "should handle when there are more than 3 of the same date w/i a range" do
+      it 'should handle when there are more than 3 of the same date w/i a range' do
         fields = mods_display_imprint(@three_imprint_dates).fields
-        fields.length.should == 1
-        fields.first.values.should == ["[1820-1825?]"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values).to eq(['[1820-1825?]'])
       end
-      it "should apply the qualifier decoration in the imprints" do
+      it 'should apply the qualifier decoration in the imprints' do
         fields = mods_display_imprint(@qualified_imprint_date).fields
-        fields.length.should == 1
-        fields.first.values.should == ["[1820?]"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values).to eq(['[1820?]'])
       end
-      it "should handle date ranges in imprints" do
+      it 'should handle date ranges in imprints' do
         fields = mods_display_imprint(@imprint_date_range).fields
-        fields.length.should == 1
-        fields.first.values.should == ["1820-1825"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values).to eq(['1820-1825'])
       end
-      it "should handle encoded dates properly" do
+      it 'should handle encoded dates properly' do
         fields = mods_display_imprint(@encoded_date_range).fields
-        fields.length.should eq 1
-        fields.first.values.should eq ["February 01, 2008-December 02, 2009"]
+        expect(fields.length).to eq 1
+        expect(fields.first.values).to eq ['February 01, 2008-December 02, 2009']
+      end
+
+      it 'should handle B.C. and A.D. dates appropriately' do
+        fields = mods_display_imprint(@bc_ad_dates).fields
+        expect(fields.length).to eq 1
+        expect(fields.first.values).to eq ['12 B.C.-44 A.D.']
       end
     end
-    describe "duplication" do
-      it "should only return the qualified date when present" do
+    describe 'duplication' do
+      it 'should only return the qualified date when present' do
         fields = mods_display_imprint(@dup_qualified_date).fields
-        fields.length.should == 1
-        fields.first.values.should == ["[1820?]"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values).to eq(['[1820?]'])
       end
-      it "should use the non-encoded date when prsent" do
+      it 'should use the non-encoded date when prsent' do
         fields = mods_display_imprint(@dup_unencoded_date).fields
-        fields.length.should == 1
-        fields.first.values.should == ["[ca. 1820]"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values).to eq(['[ca. 1820]'])
       end
-      it "should handle copyright dates correctly" do
+      it 'should handle copyright dates correctly' do
         fields = mods_display_imprint(@dup_copyright_date).fields
-        fields.length.should == 1
-        fields.first.values.should == ["c1820"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values).to eq(['c1820'])
       end
-      it "should only return one when no attributes are present" do
+      it 'should only return one when no attributes are present' do
         fields = mods_display_imprint(@dup_date).fields
-        fields.length.should == 1
-        fields.first.values.should == ["1820"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values).to eq(['1820'])
       end
     end
-    describe "qualifier decoration" do
+    describe 'qualifier decoration' do
       it "should prepend a 'c' to approximate dates" do
         fields = mods_display_imprint(@approximate_date).fields
-        fields.length.should == 1
-        fields.first.values.should == ["[ca. 1820]"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values).to eq(['[ca. 1820]'])
       end
       it "should append a '?' to a questionable dates and wrap them in square-brackets" do
         fields = mods_display_imprint(@questionable_date).fields
-        fields.length.should == 1
-        fields.first.values.should == ["[1820?]"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values).to eq(['[1820?]'])
       end
-      it "should wrap inferred dates in square-brackets" do
+      it 'should wrap inferred dates in square-brackets' do
         fields = mods_display_imprint(@inferred_date).fields
-        fields.length.should == 1
-        fields.first.values.should == ["[1820]"]
+        expect(fields.length).to eq(1)
+        expect(fields.first.values).to eq(['[1820]'])
       end
     end
-    describe "encoded dates" do
-      describe "W3CDTF" do
-        it "should handle single year dates properly" do
+    describe 'encoded dates' do
+      describe 'W3CDTF' do
+        it 'should handle single year dates properly' do
           fields = mods_display_imprint(@encoded_dates).fields
-          fields.length.should == 4
-          fields.find do |field|
-            field.label == "Imprint:"
-          end.values.should == ["2013"]
+          expect(fields.length).to eq(4)
+          expect(fields.find do |field|
+            field.label == 'Imprint:'
+          end.values).to eq(['2013'])
         end
-        it "should handle month+year dates properly" do
+        it 'should handle month+year dates properly' do
           fields = mods_display_imprint(@encoded_dates).fields
-          fields.length.should == 4
-          fields.find do |field|
-            field.label == "Date captured:"
-          end.values.should == ["July 2013"]
+          expect(fields.length).to eq(4)
+          expect(fields.find do |field|
+            field.label == 'Date captured:'
+          end.values).to eq(['July 2013'])
         end
-        it "should handle full dates properly" do
+        it 'should handle full dates properly' do
           fields = mods_display_imprint(@encoded_dates).fields
-          fields.length.should == 4
-          fields.find do |field|
-            field.label == "Date created:"
-          end.values.should == ["July 10, 2013"]
+          expect(fields.length).to eq(4)
+          expect(fields.find do |field|
+            field.label == 'Date created:'
+          end.values).to eq(['July 10, 2013'])
         end
         it "should not try to handle dates we can't parse" do
           fields = mods_display_imprint(@encoded_dates).fields
-          fields.length.should == 4
-          fields.find do |field|
-            field.label == "Date modified:"
-          end.values.should == ["Jul. 22, 2013"]
+          expect(fields.length).to eq(4)
+          expect(fields.find do |field|
+            field.label == 'Date modified:'
+          end.values).to eq(['Jul. 22, 2013'])
         end
-        it "should accept date configurations" do
+        it 'should accept date configurations' do
           fields = mods_display_format_date_imprint(@encoded_dates).fields
-          fields.length.should == 4
-          fields.find do |field|
-            field.label == "Date created:"
-          end.values.should == ["(2013) July, 10"]
-          fields.find do |field|
-            field.label == "Date captured:"
-          end.values.should == ["July (2013)"]
+          expect(fields.length).to eq(4)
+          expect(fields.find do |field|
+            field.label == 'Date created:'
+          end.values).to eq(['(2013) July, 10'])
+          expect(fields.find do |field|
+            field.label == 'Date captured:'
+          end.values).to eq(['July (2013)'])
         end
       end
     end
-    describe "bad dates" do
-      it "should ignore date values" do
+    describe 'bad dates' do
+      it 'should ignore date values' do
         fields = mods_display_imprint(@bad_dates).fields
-        fields.length.should == 2
+        expect(fields.length).to eq(2)
         fields.each do |field|
-          field.values.join.should_not include "9999"
+          expect(field.values.join).not_to include '9999'
         end
       end
-      it "should handle invalid dates by returning the original value" do
+      it 'should handle invalid dates by returning the original value' do
         fields = mods_display_imprint(@invalid_dates).fields
-        fields.length.should == 2
-        fields.last.values.should == ["1920-09-00"]
+        expect(fields.length).to eq(2)
+        expect(fields.last.values).to eq(['1920-09-00'])
       end
     end
   end
-  describe "place processing" do
-    it "should exclude encoded places" do
+
+  describe 'punctuation' do
+    it 'should not duplicate punctuation' do
+      fields = mods_display_imprint(@punctuation_imprint).fields
+      expect(fields.length).to eq 1
+      expect(fields.first.values).to eq ['San Francisco : Chronicle Books, 2015.']
+    end
+  end
+
+  describe 'place processing' do
+    it 'should exclude encoded places' do
       fields = mods_display_imprint(@encoded_place).fields
-      fields.length.should == 1
-      fields.first.values.should == ["[Amsterdam]", "[United States]", "Netherlands"]
+      expect(fields.length).to eq(1)
+      expect(fields.first.values).to eq(['[Amsterdam]', '[United States]', 'Netherlands'])
     end
     it "should translate encoded place if there isn't a text (or non-typed) value available" do
       fields = mods_display_imprint(@encoded_place).fields
-      fields.length.should == 1
-      fields.first.values.should include "Netherlands"
+      expect(fields.length).to eq(1)
+      expect(fields.first.values).to include 'Netherlands'
     end
     it "should ignore 'xx' country codes" do
       fields = mods_display_imprint(@xx_country_code).fields
-      fields.length.should == 1
-      fields.first.values.should == ["1994"]
+      expect(fields.length).to eq(1)
+      expect(fields.first.values).to eq(['1994'])
     end
   end
-  describe "to_html" do
-    it "should return the display form if one is available" do
+  describe 'to_html' do
+    it 'should return the display form if one is available' do
       html = mods_display_imprint(@display_form).to_html
-      html.scan(/<dd>/).length.should == 2
-      html.scan(/<dd>The Display Form<\/dd>/).length.should == 2
+      expect(html.scan(/<dd>/).length).to eq(2)
+      expect(html.scan(%r{<dd>The Display Form</dd>}).length).to eq(2)
     end
     it "should return the displayLabel when present if we're using the displayForm" do
-      mods_display_imprint(@display_form_with_label).to_html.should match(/<dt title='TheLabel'>TheLabel:<\/dt>/)
+      expect(mods_display_imprint(@display_form_with_label).to_html).to match(%r{<dt title='TheLabel'>TheLabel:</dt>})
     end
-    it "should have individual dt/dd pairs for mixed content" do
+    it 'should have individual dt/dd pairs for mixed content' do
       html = mods_display_imprint(@mixed).to_html
-      html.scan(/<dt title='Imprint'>Imprint:<\/dt>/).length.should == 1
-      html.scan(/<dt title='Issuance'>Issuance:<\/dt>/).length.should == 1
-      html.scan(/<dt title='Date captured'>Date captured:<\/dt>/).length.should == 1
-      html.scan(/<dd>/).length.should == 3
+      expect(html.scan(%r{<dt title='Imprint'>Imprint:</dt>}).length).to eq(1)
+      expect(html.scan(%r{<dt title='Issuance'>Issuance:</dt>}).length).to eq(1)
+      expect(html.scan(%r{<dt title='Date captured'>Date captured:</dt>}).length).to eq(1)
+      expect(html.scan(/<dd>/).length).to eq(3)
     end
   end
-
-end
+end