pennmarc 1.0.18 → 1.0.20

data/lib/pennmarc/helpers/title.rb

@@ -36,7 +36,7 @@ module PennMARC
       # @return [Array<String>] array of title values for search
       def search(record)
         record.fields(%w[245 880]).filter_map { |field|
-          next if field.tag == '880' && subfield_value_not_in?(field, '6', %w[245])
+          next if field.tag == '880' && no_subfield_value_matches?(field, '6', /^245/)
 
           join_subfields(field, &subfield_not_in?(%w[c 6 8 h]))
         }.uniq
@@ -63,7 +63,7 @@ module PennMARC
         return [] if not_a_serial?(record)
 
         record.fields(%w[245 880]).filter_map { |field|
-          next if field.tag == '880' && subfield_value_not_in?(field, '6', %w[245])
+          next if field.tag == '880' && no_subfield_value_matches?(field, '6', /^245/)
 
           join_subfields(field, &subfield_not_in?(%w[c 6 8 h]))
         }.uniq
@@ -166,7 +166,7 @@ module PennMARC
         end
         titles = standardized_titles + record.fields('880').filter_map do |field|
           next unless subfield_undefined?(field, 'i') ||
-                      subfield_value_in?(field, '6', %w[130 240 730])
+                      subfield_value?(field, '6', /^(130|240|730)/)
 
           join_subfields field, &subfield_not_in?(%w[5 6 8 e w])
         end
@@ -191,7 +191,7 @@ module PennMARC
           join_subfields(field, &subfield_not_in?(%w[5 6 8]))
         end
         titles = other_titles + record.fields('880').filter_map do |field|
-          next unless subfield_value_in? field, '6', %w[246 740]
+          next unless subfield_value? field, '6', /^(246|740)/
 
           join_subfields(field, &subfield_not_in?(%w[5 6 8]))
         end
@@ -263,7 +263,7 @@ module PennMARC
         record.fields(tags).filter_map do |field|
           next if field.tag == '505' && indicators_are_not_value?(field, '0')
 
-          next if field.tag == '880' && subfield_value_not_in?(field, '6', tags)
+          next if field.tag == '880' && no_subfield_value_matches?(field, '6', /^(#{tags.join('|')})/)
 
           join_subfields(field, &join_selector)
         end

data/lib/pennmarc/mappings/locations.yml

@@ -1579,6 +1579,10 @@ vpfeatdvd:
   specific_location: Van Pelt - Featured DVD Display - First Floor
   library: Van Pelt-Dietrich Library Center
   display: Van Pelt - Featured DVD Display - First Floor
+vpfolio:
+  specific_location: Van Pelt - Folios
+  library: Van Pelt-Dietrich Library Center
+  display: Van Pelt Library
 vpjuv:
   specific_location: Van Pelt - Notable Juvenile Books
   library: Van Pelt-Dietrich Library Center

data/lib/pennmarc/util.rb

@@ -46,6 +46,16 @@ module PennMARC
       field&.any? { |sf| sf.code == subfield.to_s && sf.value =~ regex }
     end
 
+    # returns true if field has no value that matches
+    # passed-in regex and passed in subfield
+    # @param [MARC::DataField] field
+    # @param [String|Integer|Symbol] subfield
+    # @param [Regexp] regex
+    # @return [TrueClass, FalseClass, nil]
+    def no_subfield_value_matches?(field, subfield, regex)
+      field&.none? { |sf| sf.code == subfield.to_s && sf.value =~ regex }
+    end
+
     # returns true if a given field has a given subfield value in a given array
     # TODO: example usage
     # @param [MARC:DataField] field
@@ -161,7 +171,7 @@ module PennMARC
     # @return [Array] array of linked alternates
     def linked_alternate(record, subfield6_value, &selector)
       record.fields('880').filter_map do |field|
-        next unless subfield_value?(field, '6', /^#{Array.wrap(subfield6_value).join('|')}/)
+        next unless subfield_value?(field, '6', /^(#{Array.wrap(subfield6_value).join('|')})/)
 
         field.select(&selector).map(&:value).join(' ')
       end
@@ -251,7 +261,7 @@ module PennMARC
       record.fields(%w[650 880]).filter_map { |field|
         next unless field.indicator2 == '4'
 
-        next if field.tag == '880' && subfield_values(field, '6').exclude?('650')
+        next if field.tag == '880' && no_subfield_value_matches?(field, '6', /^650/)
 
         next unless field.any? { |sf| sf.code == 'a' && sf.value =~ /^(#{prefix}|%#{prefix})/ }
 
@@ -268,5 +278,56 @@ module PennMARC
     def valid_subject_genre_source_code?(field)
       subfield_value_in?(field, '2', PennMARC::HeadingControl::ALLOWED_SOURCE_CODES)
     end
+
+    # Does a field or its linked alternate match any of the specified tags?
+    # @param [MARC::Field] field
+    # @param [Array<String>] tags
+    # @return [TrueClass, FalseClass]
+    def field_or_its_linked_alternate?(field, tags)
+      return true if field.tag.in? tags
+      return true if field.tag == '880' && subfield_value?(field, '6', /^(#{tags.join('|')})/)
+
+      false
+    end
+
+    # Match any open dates ending a given string to determine join separator for relator term in 1xx/7xx fields.
+    # @param [String] str
+    # @return [String (frozen)]
+    def relator_join_separator(str)
+      /\b\d+-\z/.match?(str) ? ' ' : ', '
+    end
+
+    # For a given field, determine in which subfield to find relator term
+    # The following fields and their linked alternates use $j for relator terms:
+    # {https://www.loc.gov/marc/bibliographic/bd111.html 111}, {https://www.loc.gov/marc/bibliographic/bd411.html 411},
+    # {https://www.loc.gov/marc/bibliographic/bd611.html 611}, {https://www.loc.gov/marc/bibliographic/bd711.html 711},
+    # {https://www.loc.gov/marc/bibliographic/bd811.html 811}
+    # @param [MARC:Field] field
+    # @return [String (frozen)]
+    def relator_term_subfield(field)
+      field_or_its_linked_alternate?(field, %w[111 411 611 711 811]) ? 'j' : 'e'
+    end
+
+    # Appends a relator value to the given string. It prioritizes relator codes found in subfield $4
+    # and falls back to the specified relator term subfield (defaulting to 'e') if no valid codes are found in $4.
+    # Use with 1xx/7xx fields.
+    # @param [MARC::Field] field where relator values are stored
+    # @param [String] joined_subfields the string to which the relator is appended
+    # @param [String] relator_term_sf MARC subfield that stores relator term
+    # @param [Hash] relator_map
+    # @return [String]
+    def append_relator(field:, joined_subfields:, relator_term_sf:, relator_map: Mappers.relator)
+      joined_subfields = trim_trailing(:comma, joined_subfields)
+
+      join_separator = relator_join_separator(joined_subfields)
+
+      relator = subfield_values(field, '4').filter_map { |code| translate_relator(code, relator_map) }
+
+      relator = subfield_values(field, relator_term_sf) if relator.blank?
+
+      relator = append_trailing(:period, relator.join(', ')) if relator.present?
+
+      [joined_subfields, relator].compact_blank.join(join_separator).squish
+    end
   end
 end

data/lib/pennmarc/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module PennMARC
-  VERSION = '1.0.18'
+  VERSION = '1.0.20'
 end

data/spec/lib/pennmarc/helpers/creator_spec.rb

@@ -18,8 +18,8 @@ describe 'PennMARC::Creator' do
 
       it 'contains the expected search field values for a single author work' do
         expect(helper.search(record, relator_map: mapping)).to contain_exactly(
-          'Name Surname http://cool.uri/12345 author 1900-2000.',
-          'Surname, Name http://cool.uri/12345 author 1900-2000.',
+          'Name Surname http://cool.uri/12345 1900-2000, author.',
+          'Surname, Name http://cool.uri/12345 1900-2000, author.',
           'Alternative Surname'
         )
       end
@@ -63,62 +63,103 @@ describe 'PennMARC::Creator' do
     end
   end
 
-  describe '.values' do
+  describe '.show' do
     let(:record) { marc_record fields: fields }
 
     context 'with a single author record' do
       let(:fields) do
-        [marc_field(tag: '100', subfields: { a: 'Author', c: 'Fancy', d: 'active 24th century AD', '4': 'aut' }),
-         marc_field(tag: '880', subfields: { '6': '100', a: 'Alt Author', c: 'Alt Fanciness' })]
+        [marc_field(tag: '100', subfields: { a: 'Surname, Name', '0': 'http://cool.uri/12345', d: '1900-2000',
+                                             e: 'author.', '4': 'http://cool.uri/vocabulary/relators/aut' }),
+         marc_field(tag: '880', subfields: { a: 'Surname, Alternative', '6': '100' })]
       end
 
-      it 'returns values for the author, including mapped relator code from ǂ4' do
-        values = helper.values(record, relator_map: mapping)
-        expect(values).to contain_exactly 'Author Fancy active 24th century AD, Author.'
-        expect(values.join.downcase).not_to include 'alt'
+      it 'returns single author values with no URIs anywhere' do
+        values = helper.show(record)
+        expect(values).to contain_exactly 'Surname, Name 1900-2000, author.', 'Surname, Alternative'
+        expect(values.join.downcase).not_to include 'http'
       end
     end
 
     context 'with a corporate author record' do
       let(:fields) do
-        [marc_field(tag: '110', subfields: { a: 'Annual Report', b: 'Leader', e: 'author', '4': 'aut' })]
+        [marc_field(tag: '110', subfields: { a: 'Group of People', b: 'Annual Meeting', '4': 'aut' }),
+         marc_field(tag: '880', subfields: { '6': '110', a: 'Alt. Group Name', b: 'Alt. Annual Meeting' })]
       end
 
-      it 'returns values for the corporate author, including mapped relator code from ǂ4' do
-        expect(helper.values(record, relator_map: mapping)).to contain_exactly(
-          'Annual Report Leader author, Author.'
-        )
+      it 'returns corporate author values with no URIs anywhere' do
+        values = helper.show(record, relator_map: mapping)
+        expect(values).to contain_exactly 'Alt. Group Name Alt. Annual Meeting',
+                                          'Group of People Annual Meeting, Author.'
+        expect(values.join.downcase).not_to include 'http'
       end
     end
   end
 
-  describe '.show' do
+  describe '.show_aux' do
     let(:record) { marc_record fields: fields }
 
     context 'with a single author record' do
       let(:fields) do
-        [marc_field(tag: '100', subfields: { a: 'Surname, Name', '0': 'http://cool.uri/12345', d: '1900-2000',
-                                             e: 'author', '4': 'http://cool.uri/vocabulary/relators/aut' }),
-         marc_field(tag: '880', subfields: { a: 'Surname, Alternative', '6': '100' })]
+        [marc_field(tag: '100', subfields: { a: 'Person', c: 'Loquacious', d: 'active 24th century AD', '4': 'aut' }),
+         marc_field(tag: '880', subfields: { '6': '100', a: 'Alt Author', c: 'Alt Fanciness' })]
       end
 
-      it 'returns single author values with no URIs anywhere' do
-        values = helper.show(record)
-        expect(values).to contain_exactly 'Surname, Name 1900-2000', 'Surname, Alternative'
-        expect(values.join.downcase).not_to include 'http'
+      it 'returns mapped relator code from ǂ4 at the end with a terminal period' do
+        expect(helper.show_aux(record, relator_map: mapping).first).to end_with ', Author.'
+      end
+
+      it 'does not include linked 880 field' do
+        expect(helper.show_aux(record, relator_map: mapping).join(' ')).not_to include 'Alt'
       end
     end
 
     context 'with a corporate author record' do
       let(:fields) do
-        [marc_field(tag: '110', subfields: { a: 'Group of People', b: 'Annual Meeting', '4': 'aut' }),
-         marc_field(tag: '880', subfields: { '6': '110', a: 'Alt. Group Name', b: 'Alt. Annual Meeting' })]
+        [marc_field(tag: '110', subfields: { a: 'Annual Report', b: 'Leader', e: 'author', '4': 'aut' })]
       end
 
-      it 'returns corporate author values with no URIs anywhere' do
-        values = helper.show(record)
-        expect(values).to contain_exactly 'Alt. Group Name Alt. Annual Meeting', 'Group of People Annual Meeting'
-        expect(values.join.downcase).not_to include 'http'
+      it 'returns values for the corporate author, including mapped relator code from ǂ4' do
+        expect(helper.show_aux(record, relator_map: mapping)).to contain_exactly(
+          'Annual Report Leader, Author.'
+        )
+      end
+    end
+
+    context 'with relator term and translatable relator code' do
+      let(:fields) do
+        [marc_field(tag: '100', subfields: { a: 'Person', c: 'Loquacious', d: 'active 24th century AD', e: 'Ignore',
+                                             '4': 'aut' })]
+      end
+
+      it 'only appends translatable relator' do
+        expect(helper.show_aux(record, relator_map: mapping)).to contain_exactly(
+          'Person Loquacious active 24th century AD, Author.'
+        )
+      end
+    end
+
+    context 'with multiple translatable relator codes' do
+      let(:mapping) { { aut: 'Author', stl: 'Storyteller' } }
+      let(:fields) do
+        [marc_field(tag: '100', subfields: { a: 'Person', c: 'Loquacious', d: 'active 24th century AD',
+                                             '4': %w[aut stl] })]
+      end
+
+      it 'appends all translatable relators' do
+        expect(helper.show_aux(record, relator_map: mapping)).to contain_exactly(
+          'Person Loquacious active 24th century AD, Author, Storyteller.'
+        )
+      end
+    end
+
+    context 'without translatable relator code' do
+      let(:fields) do
+        [marc_field(tag: '100', subfields: { a: 'Person', c: 'Loquacious', d: 'active 24th century AD',
+                                             e: 'author' })]
+      end
+
+      it 'appends all translatable relators' do
+        expect(helper.show_aux(record)).to contain_exactly('Person Loquacious active 24th century AD, author.')
       end
     end
   end
@@ -197,18 +238,22 @@ describe 'PennMARC::Creator' do
   describe '.conference_detail_show' do
     let(:record) do
       marc_record fields: [
-        marc_field(tag: '111', subfields: { a: 'MARC History Symposium', c: 'Moscow' }),
+        marc_field(tag: '111', subfields: { a: 'MARC History Symposium', e: 'Advisory Committee', c: 'Moscow',
+                                            j: 'author', '4': 'aut' }),
         marc_field(tag: '711', subfields: { a: 'Russian Library Conference', j: 'author' }),
         marc_field(tag: '711', indicator2: '1', subfields: { a: 'Ignored Entry', j: 'author' }),
         marc_field(tag: '880', subfields: { a: 'Proceedings', '6': '111' }),
+        marc_field(tag: '880', subfields: { a: 'Opening Remarks', j: 'author', '4': 'aut', '6': '711' }),
         marc_field(tag: '880', subfields: { a: 'Not Included', i: 'something', '6': '111' })
       ]
     end
 
     it 'returns detailed conference name information for display, including linked 880 fields without ǂi, and ignoring
         any 111 or 711 with a defined indicator 2 value' do
-      expect(helper.conference_detail_show(record)).to eq ['MARC History Symposium Moscow',
-                                                           'Russian Library Conference author', 'Proceedings']
+      expect(helper.conference_detail_show(record, relator_map: mapping)).to contain_exactly(
+        'MARC History Symposium Moscow Advisory Committee, Author.',
+        'Russian Library Conference, author.', 'Proceedings', 'Opening Remarks, Author.'
+      )
     end
   end
 
@@ -225,33 +270,72 @@ describe 'PennMARC::Creator' do
   end
 
   describe '.contributor_show' do
-    let(:record) do
-      marc_record fields: [
-        marc_field(tag: '700', subfields: { a: 'Name', b: 'I', c: 'laureate', d: '1968', e: 'author',
-                                            j: 'pseud', q: 'Fuller Name', u: 'affiliation', '3': 'materials',
-                                            '4': 'aut' }),
-        marc_field(tag: '700', subfields: { a: 'Ignore' }, indicator2: '1'),
-        marc_field(tag: '700', subfields: { i: 'Ignore' }),
-        marc_field(tag: '710', subfields: { a: 'Corporation', b: 'A division', c: 'Office', d: '1968', e: 'author',
-                                            u: 'affiliation', '3': 'materials',
-                                            '4': 'aut' }),
-        marc_field(tag: '880', subfields: {  '6': '700', a: 'Alt Name', b: 'Alt num', c: 'Alt title',
-                                             d: 'Alt date', e: 'Alt relator', j: 'Alt qualifier', q: 'Alt Fuller Name',
-                                             u: 'Alt affiliation', '3': 'Alt materials' }),
-        marc_field(tag: '880', subfields: { '6': '710', a: 'Alt Corp Name', b: 'Alt unit', c: 'Alt location',
-                                            d: 'Alt date', e: 'Alt relator', u: 'Alt Affiliation',
-                                            '3': 'Alt materials' }),
-        marc_field(tag: '880', subfields: { i: 'Ignore', '6': '700' })
-      ]
+    let(:record) { marc_record fields: fields }
+
+    context 'when idicator2 is "1"' do
+      let(:fields) do
+        [marc_field(tag: '700', subfields: { a: 'Ignore' }, indicator2: '1')]
+      end
+
+      it 'ignores the field' do
+        values = helper.contributor_show(record, relator_map: mapping)
+        expect(values).to be_empty
+      end
     end
 
-    it 'returns expected contributor values' do
-      expect(helper.contributor_show(record, relator_map: mapping)).to contain_exactly(
-        'Name I laureate 1968 pseud Fuller Name author affiliation materials, Author',
-        'Corporation A division Office 1968 author affiliation materials, Author',
-        'Alt Name Alt num Alt title Alt date Alt qualifier Alt Fuller Name Alt relator Alt affiliation Alt materials',
-        'Alt Corp Name Alt unit Alt location Alt date Alt relator Alt Affiliation Alt materials'
-      )
+    context 'with subfield "i"' do
+      let(:fields) do
+        [
+          marc_field(tag: '700', subfields: { i: 'Ignore' }),
+          marc_field(tag: '880', subfields: { i: 'Ignore', '6': '700' })
+        ]
+      end
+
+      it 'ignores the field' do
+        values = helper.contributor_show(record, relator_map: mapping)
+        expect(values).to be_empty
+      end
+    end
+
+    context 'with a single contributor and linked alternate' do
+      let(:fields) do
+        [
+          marc_field(tag: '700', subfields: { a: 'Name', b: 'I', c: 'laureate', d: '1968', e: 'author',
+                                              j: 'pseud', q: 'Fuller Name', u: 'affiliation', '3': 'materials',
+                                              '4': 'aut' }),
+          marc_field(tag: '880', subfields: {  '6': '700', a: 'Alt Name', b: 'Alt num', c: 'Alt title',
+                                               d: 'Alt date', e: 'Alt relator', j: 'Alt qualifier',
+                                               q: 'Alt Fuller Name', u: 'Alt affiliation', '3': 'Alt material' })
+        ]
+      end
+
+      it 'returns expected contributor values' do
+        values = helper.contributor_show(record, relator_map: mapping)
+        expect(values).to contain_exactly(
+          'Name I laureate 1968 pseud Fuller Name affiliation materials, Author.',
+          'Alt Name Alt num Alt title Alt date Alt qualifier Alt Fuller Name Alt affiliation Alt material, Alt relator.'
+        )
+      end
+    end
+
+    context 'with a corporate contributor and linked alternate' do
+      let(:fields) do
+        [
+          marc_field(tag: '710', subfields: { a: 'Corporation', b: 'A division', c: 'Office', d: '1968', e: 'author',
+                                              u: 'affiliation', '3': 'materials', '4': 'aut' }),
+          marc_field(tag: '880', subfields: { '6': '710', a: 'Alt Corp Name', b: 'Alt unit', c: 'Alt location',
+                                              d: 'Alt date', e: ['Alt relator', 'another'], u: 'Alt Affiliation',
+                                              '3': 'Alt materials' })
+        ]
+      end
+
+      it 'returns expected contributor values' do
+        values = helper.contributor_show(record)
+        expect(values).to contain_exactly(
+          'Corporation A division Office 1968 affiliation materials, Author.',
+          'Alt Corp Name Alt unit Alt location Alt date Alt Affiliation Alt materials, Alt relator, another.'
+        )
+      end
     end
   end
 end