mods_display 0.9.1 → 1.0.0.alpha2

data/spec/fields/identifier_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-def mods_display_id(mods_record)
-  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
-  end
-  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
-      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
-      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
-      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
-      fields = mods_display_id(@complex_label).fields
-      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

data/spec/fields/imprint_spec.rb

@@ -1,289 +0,0 @@
-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'))
-end
-
-def mods_display_format_date_imprint(mods_record)
-  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
-  before(:all) do
-    @imprint = Stanford::Mods::Record.new.from_str(imprint_mods, false).origin_info
-    @no_edition = Stanford::Mods::Record.new.from_str(no_edition_mods, false).origin_info
-    @edition_and_date = Stanford::Mods::Record.new.from_str(origin_info_mods, false).origin_info
-    @mixed = Stanford::Mods::Record.new.from_str(mixed_mods, false).origin_info
-    @display_form = Stanford::Mods::Record.new.from_str(display_form, false).origin_info
-    @display_form_with_label = Stanford::Mods::Record.new.from_str(display_form, false).origin_info
-    @display_label = Stanford::Mods::Record.new.from_str(display_label, false).origin_info
-    @date_range = Stanford::Mods::Record.new.from_str(date_range, false).origin_info
-    @open_date_range = Stanford::Mods::Record.new.from_str(open_date_range, false).origin_info
-    @encoded_date_range = Stanford::Mods::Record.new.from_str(encoded_date_range, false).origin_info
-    @dup_qualified_date = Stanford::Mods::Record.new.from_str(dup_qualified_date, false).origin_info
-    @dup_unencoded_date = Stanford::Mods::Record.new.from_str(dup_unencoded_date, false).origin_info
-    @dup_copyright_date = Stanford::Mods::Record.new.from_str(dup_copyright_date, false).origin_info
-    @dup_date = Stanford::Mods::Record.new.from_str(dup_date, false).origin_info
-    @approximate_date = Stanford::Mods::Record.new.from_str(approximate_date, false).origin_info
-    @questionable_date = Stanford::Mods::Record.new.from_str(questionable_date, false).origin_info
-    @inferred_date = Stanford::Mods::Record.new.from_str(inferred_date, false).origin_info
-    @three_imprint_dates = Stanford::Mods::Record.new.from_str(three_imprint_dates, false).origin_info
-    @xx_country_code = Stanford::Mods::Record.new.from_str(xx_country_code, false).origin_info
-    @qualified_imprint_date = Stanford::Mods::Record.new.from_str(qualified_imprint_date, false).origin_info
-    @imprint_date_range = Stanford::Mods::Record.new.from_str(imprint_date_range, false).origin_info
-    @encoded_place = Stanford::Mods::Record.new.from_str(encoded_place, false).origin_info
-    @encoded_dates = Stanford::Mods::Record.new.from_str(encoded_dates, false).origin_info
-    @iso8601_encoded_dates = Stanford::Mods::Record.new.from_str(iso8601_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
-      expect(mods_display_imprint(@imprint).fields.first.label).to eq('Imprint:')
-    end
-    it 'should get the label from non-imprint origin info fields' do
-      fields = mods_display_imprint(@edition_and_date).fields
-      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
-      expect(mods_display_imprint(@mixed).fields.map(&:label)).to eq(['Imprint:', 'Date captured:', 'Issuance:'])
-    end
-    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
-      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(&: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
-      fields = mods_display_imprint(@edition_and_date).fields
-      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
-      values = mods_display_imprint(@mixed).fields
-      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
-      it "should join start and end point ranges with a '-'" do
-        fields = mods_display_imprint(@date_range).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.values).to eq(['1820-1825'])
-      end
-      it 'should handle open ranges properly' do
-        fields = mods_display_imprint(@open_date_range).fields
-        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
-        fields = mods_display_imprint(@three_imprint_dates).fields
-        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
-        fields = mods_display_imprint(@qualified_imprint_date).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.values).to eq(['[1820?]'])
-      end
-      it 'should handle date ranges in imprints' do
-        fields = mods_display_imprint(@imprint_date_range).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.values).to eq(['1820-1825'])
-      end
-      it 'should handle encoded dates properly' do
-        fields = mods_display_imprint(@encoded_date_range).fields
-        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 ['14 B.C.-44 A.D.']
-      end
-    end
-    describe 'duplication' do
-      it 'should only return the qualified date when present' do
-        fields = mods_display_imprint(@dup_qualified_date).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.values).to eq(['[1820?]'])
-      end
-      it 'should use the non-encoded date when prsent' do
-        fields = mods_display_imprint(@dup_unencoded_date).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.values).to eq(['[ca. 1820]'])
-      end
-      it 'should handle copyright dates correctly' do
-        fields = mods_display_imprint(@dup_copyright_date).fields
-        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
-        fields = mods_display_imprint(@dup_date).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.values).to eq(['1820'])
-      end
-    end
-    describe 'qualifier decoration' do
-      it "should prepend a 'c' to approximate dates" do
-        fields = mods_display_imprint(@approximate_date).fields
-        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
-        expect(fields.length).to eq(1)
-        expect(fields.first.values).to eq(['[1820?]'])
-      end
-      it 'should wrap inferred dates in square-brackets' do
-        fields = mods_display_imprint(@inferred_date).fields
-        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
-          fields = mods_display_imprint(@encoded_dates).fields
-          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
-          fields = mods_display_imprint(@encoded_dates).fields
-          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
-          fields = mods_display_imprint(@encoded_dates).fields
-          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
-          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
-          fields = mods_display_format_date_imprint(@encoded_dates).fields
-          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
-
-      describe 'iso8601' do
-        it 'handles full dates properly' do
-          fields = mods_display_imprint(@iso8601_encoded_dates).fields
-          expect(fields.length).to eq(2)
-          expect(fields.find do |field|
-            field.label == 'Date created:'
-          end.values).to eq(['November 14, 2013'])
-        end
-        it "should not try to handle dates we can't parse" do
-          fields = mods_display_imprint(@iso8601_encoded_dates).fields
-          expect(fields.length).to eq(2)
-          expect(fields.find do |field|
-            field.label == 'Date modified:'
-          end.values).to eq(['Jul. 22, 2013'])
-        end
-      end
-    end
-    describe 'bad dates' do
-      it 'should ignore date values' do
-        fields = mods_display_imprint(@bad_dates).fields
-        expect(fields.length).to eq(2)
-        fields.each do |field|
-          expect(field.values.join).not_to include '9999'
-        end
-      end
-      it 'should handle invalid dates by returning the original value' do
-        fields = mods_display_imprint(@invalid_dates).fields
-        expect(fields.length).to eq(2)
-        expect(fields.last.values).to eq(['1920-09-00'])
-      end
-    end
-  end
-
-  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
-      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
-      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
-      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
-      html = mods_display_imprint(@display_form).to_html
-      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
-      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
-      html = mods_display_imprint(@mixed).to_html
-      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

data/spec/fields/language_spec.rb

@@ -1,51 +0,0 @@
-require 'spec_helper'
-
-def mods_display_language(mods_record)
-  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
-  end
-  describe 'fields' do
-    it 'should return an array with a label/values object' do
-      values = mods_display_language(@display_label).fields
-      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
-      expect(values.length).to eq(1)
-      expect(values.first.values).to eq(['English'])
-    end
-    it 'should handle multiple languages correctly' do
-      values = mods_display_language(@multi).fields
-      expect(values.length).to eq(1)
-      expect(values.first.values).to eq(%w(German English))
-    end
-  end
-end

data/spec/fields/location_spec.rb

@@ -1,81 +0,0 @@
-require 'spec_helper'
-
-describe ModsDisplay::Location do
-  let(:location_mods) do
-    <<-XML
-      <mods>
-        <location>
-          <shelfLocation>On Shelf A</shelfLocation>
-        </location>
-      </mods>
-    XML
-  end
-
-  let(:url_mods) do
-    <<-XML
-      <mods>
-        <location>
-          <url displayLabel='Stanford University Library'>http://library.stanford.edu</url>
-        </location>
-        <location displayLabel='PURL'>
-          <url>http://purl.stanford.edu</url>
-        </location>
-      </mods>
-    XML
-  end
-
-  let(:repository_mods) do
-    <<-XML
-      <mods>
-        <location>
-          <physicalLocation type='repository'>Location Field</physicalLocation>
-        </location>
-      </mods>
-    XML
-  end
-
-  let(:location) do
-    mods = Stanford::Mods::Record.new.from_str(location_mods, false).location
-    described_class.new(mods, ModsDisplay::Configuration::Base.new, double('controller')).fields
-  end
-
-  let(:urls) do
-    mods = Stanford::Mods::Record.new.from_str(url_mods, false).location
-    described_class.new(mods, ModsDisplay::Configuration::Base.new, double('controller')).fields
-  end
-
-  let(:repository_label) do
-    mods = Stanford::Mods::Record.new.from_str(repository_mods, false).location
-    described_class.new(mods, ModsDisplay::Configuration::Base.new, double('controller')).fields
-  end
-
-  describe 'label' do
-    it 'should have a default label' do
-      expect(location.first.label).to eq 'Location:'
-    end
-
-    it 'should handle the URL labels correctly' do
-      expect(urls.map(&:label)).to eq ['Location:', 'PURL:']
-    end
-
-    it 'should use get a label from a list of translations' do
-      expect(repository_label.first.label).to eq 'Repository:'
-    end
-  end
-
-  describe 'fields' do
-    describe 'URLs' do
-      it 'should link and use the displayLabel as text' do
-        expect(urls.length).to eq(2)
-        field = urls.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
-        expect(urls.length).to eq(2)
-        field = urls.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

data/spec/fields/name_spec.rb

@@ -1,166 +0,0 @@
-require 'spec_helper'
-require 'fixtures/name_fixtures'
-include NameFixtures
-
-def mods_display_name_link(mods_record)
-  config = ModsDisplay::Configuration::Base.new do
-    link :link_method, '%value%'
-  end
-  ModsDisplay::Name.new(mods_record, config, TestController.new)
-end
-
-def mods_display_name(mods_record)
-  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(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
-    @primary_name_solo = Stanford::Mods::Record.new.from_str(primary_name_solo_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
-    @author_role = Stanford::Mods::Record.new.from_str(author_role_fixture, false).plain_name
-    @many_roles_and_names = Stanford::Mods::Record.new.from_str(many_roles_and_names_fixture, false).plain_name
-    @names_with_code_and_text_roles = Stanford::Mods::Record.new.from_str(names_with_code_and_text_roles_fixture, false).plain_name
-  end
-  let(:default_label) { 'Associated with:' }
-
-  describe 'label' do
-    it 'should default Author/Creator when no role is available' do
-      expect(mods_display_name(@name).fields.first.label).to eq(default_label)
-    end
-    it "should label as role for primary authors with a role" do
-      expect(mods_display_name(@primary_name).fields.first.label).to eq('Lithographer:')
-    end
-    it "should label 'Author/Creator' for non-role primary authors" do
-      expect(mods_display_name(@primary_name_solo).fields.first.label).to eq(default_label)
-    end
-    it 'should apply role labeling with text' do
-      expect(mods_display_name(@contributor).fields.first.label).to eq('Lithographer:')
-    end
-    it 'should apply role labeling with code' do
-      expect(mods_display_name(@author_role).fields.first.label).to eq('Author:')
-    end
-  end
-
-  describe 'fields' do
-    it 'should use the display form when available' do
-      fields = mods_display_name(@display_form).fields
-      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
-      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
-      fields = mods_display_name(@numeral_toa).fields
-      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
-      fields = mods_display_name(@simple_toa).fields
-      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
-      fields = mods_display_name(@collapse_label).fields
-      expect(fields.length).to eq(1)
-      expect(fields.first.label).to eq(default_label)
-      fields.first.values.each do |val|
-        expect(['John Doe', 'Jane Doe']).to include val.to_s
-      end
-    end
-    it 'should perseve order and separation of non-adjesent matching labels' do
-      fields = mods_display_name(@complex_labels).fields
-
-      expect(fields.length).to eq(2)
-      expect(fields.first.label).to eq(default_label)
-      expect(fields.first.values.length).to eq(3)
-      expect(fields.first.values.map(&:to_s)).to include 'John Doe', 'Jane Dough', 'John Dough'
-
-      expect(fields[1].label).to eq('Lithographer:')
-      expect(fields[1].values.length).to eq(1)
-      expect(fields[1].values.first.name).to eq('Jane Doe')
-    end
-    describe 'roles' do
-      it 'should get the role when present' do
-        fields = mods_display_name(@name_with_role).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.label).to eq('Depicted:')
-        expect(fields.first.values.length).to eq(1)
-        expect(fields.first.values.first).to be_a(ModsDisplay::Name::Person)
-      end
-      it 'should decode encoded roleTerms when no text (or non-typed) roleTerm is available' do
-        fields = mods_display_name(@encoded_role).fields
-        expect(fields.length).to eq(1)
-        expect(fields.first.label).to eq('Lithographer:')
-        expect(fields.first.values.length).to eq(1)
-        expect(fields.first.values.first.to_s).to eq('John Doe')
-      end
-      it "should get the type='text' role before an untyped role" do
-        fields = mods_display_name(@mixed_role).fields
-        expect(fields.length).to eq(2)
-        expect(fields.first.label).to eq 'Publisher:'
-        expect(fields.last.label).to eq 'Engraver:'
-        expect(fields.first.values.length).to eq(1)
-        expect(fields.last.values.length).to eq(1)
-        expect(fields.first.values.first.name).to eq fields.last.values.first.name
-      end
-      it 'should be handled correctly when there are more than one' do
-        fields = mods_display_name(@multiple_roles).fields
-        expect(fields.length).to eq 2
-        expect(fields.first.label).to eq 'Depicted:'
-        expect(fields.last.label).to eq 'Artist:'
-        expect(fields.first.values.length).to eq(1)
-        expect(fields.last.values.length).to eq(1)
-        expect(fields.first.values.first.name).to eq fields.last.values.first.name
-      end
-      it 'should handle code and text roleTerms together correctly' do
-        fields = mods_display_name(@complex_roles).fields
-        expect(fields.length).to eq 2
-        expect(fields.first.label).to eq 'Depicted:'
-        expect(fields.last.label).to eq 'Depositor:'
-        expect(fields.first.values.first.name).to eq fields.last.values.first.name
-      end
-      it 'should handle consolidation of many roles and names' do
-        fields = mods_display_name(@many_roles_and_names).fields
-        expect(fields.length).to eq 6
-        expect(fields.map(&:label)).to eq %w[Associated\ with: Surveyor: Cartographer: Editor: Electrotyper: Lithographer:]
-      end
-      it 'should handle consolidation of names with both code and text roleTerms' do
-        fields = mods_display_name(@names_with_code_and_text_roles).fields
-        expect(fields.length).to eq 3
-        expect(fields.map(&:label)).to eq %w[Author: Printer: Donor:]
-      end
-    end
-  end
-
-  describe 'to_html' do
-    it 'should add the role to the name in parens' do
-      html = mods_display_name(@name_with_role).to_html
-      expect(html).to match(%r{<dd>John Doe</dd>})
-    end
-    it 'should link the name and not the role if requested' do
-      html = mods_display_name_link(@name_with_role).to_html
-      expect(html).to match(%r{<dd><a href='.*\?John Doe'>John Doe</a></dd>})
-    end
-  end
-end