pennmarc 1.0.25 → 1.0.27

data/lib/pennmarc/util.rb

@@ -13,16 +13,16 @@ module PennMARC
                                        period: /\.\s*$/ }.freeze # TODO: revise to exclude "etc."
 
     # Check if a given record has a field present by tag (e.g., '041')
-    # @param [MARC::Record] record
-    # @param [String] marc_field
+    # @param record [MARC::Record]
+    # @param marc_field [String]
     # @return [Boolean]
     def field_defined?(record, marc_field)
       record.select { |field| field.tag == marc_field }.any?
     end
 
     # Join subfields from a field selected based on a provided proc
-    # @param [MARC::DataField, nil] field
-    # @param [Proc] selector
+    # @param field [MARC::DataField, nil]
+    # @param selector [Proc]
     # @return [String]
     def join_subfields(field, &selector)
       return '' unless field
@@ -37,77 +37,75 @@ module PennMARC
 
     # returns true if field has a value that matches
     # passed-in regex and passed in subfield
-    # @todo example usage
-    # @param [MARC::DataField] field
-    # @param [String|Integer|Symbol] subfield
-    # @param [Regexp] regex
-    # @return [TrueClass, FalseClass]
+    # @param field [MARC::DataField]
+    # @param subfield [String|Integer|Symbol]
+    # @param regex [Regexp]
+    # @return [Boolean, nil]
     def subfield_value?(field, subfield, regex)
       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]
+    # @param field [MARC::DataField]
+    # @param subfield [String|Integer|Symbol]
+    # @param regex [Regexp]
+    # @return [Boolean, 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
-    # @param [String|Integer|Symbol] subfield
-    # @param [Array] array
-    # @return [TrueClass, FalseClass]
+    # @param field [MARC:DataField]
+    # @param subfield [String|Integer|Symbol]
+    # @param array [Array]
+    # @return [Boolean]
     def subfield_value_in?(field, subfield, array)
       field.any? { |sf| sf.code == subfield.to_s && sf.value.in?(array) }
     end
 
     # returns true if a given field does not have a given subfield value in a given array
-    # @param [MARC:DataField] field
-    # @param [String|Integer|Symbol] subfield
-    # @param [Array] array
-    # @return [TrueClass, FalseClass
+    # @param field [MARC:DataField]
+    # @param subfield [String|Integer|Symbol]
+    # @param array [Array]
+    # @return [Boolean]
     def subfield_value_not_in?(field, subfield, array)
       field.none? { |sf| sf.code == subfield.to_s && sf.value.in?(array) }
     end
 
     # returns a lambda checking if passed-in subfield's code is a member of array
-    # @param [Array] array
+    # @param array [Array]
     # @return [Proc]
     def subfield_in?(array)
       ->(subfield) { array.member?(subfield.code) }
     end
 
     # returns a lambda checking if passed-in subfield's code is NOT a member of array
-    # @param [Array] array
+    # @param array [Array]
     # @return [Proc]
     def subfield_not_in?(array)
       ->(subfield) { !array.member?(subfield.code) }
     end
 
     # Check if a field has a given subfield defined
-    # @param [MARC::DataField] field
-    # @param [String|Symbol|Integer] subfield
-    # @return [TrueClass, FalseClass]
+    # @param field [MARC::DataField]
+    # @param subfield [String|Symbol|Integer]
+    # @return [Boolean]
     def subfield_defined?(field, subfield)
       field.any? { |sf| sf.code == subfield.to_s }
     end
 
     # Check if a field does not have a given subfield defined
-    # @param [MARC::DataField] field
-    # @param [String|Symbol|Integer] subfield
-    # @return [TrueClass, FalseClass]
+    # @param field [MARC::DataField]
+    # @param subfield [String|Symbol|Integer]
+    # @return [Boolean]
     def subfield_undefined?(field, subfield)
       field.none? { |sf| sf.code == subfield.to_s }
     end
 
     # Gets all subfield values for a subfield in a given field
-    # @param [MARC::DataField] field
-    # @param [String|Symbol] subfield as a string or symbol
+    # @param field [MARC::DataField]
+    # @param subfield [String|Symbol] as a string or symbol
     # @return [Array] subfield values for given subfield code
     def subfield_values(field, subfield)
       field.filter_map do |sf|
@@ -120,9 +118,9 @@ module PennMARC
     end
 
     # Get all subfield values for a provided subfield from any occurrence of a provided tag/tags
-    # @param [String|Array] tag tags to consider
-    # @param [String|Symbol] subfield to take the values from
-    # @param [MARC::Record] record source
+    # @param tag [String|Array] tags to consider
+    # @param subfield [String|Symbol] to take the values from
+    # @param record [MARC::Record]
     # @return [Array] array of subfield values
     def subfield_values_for(tag:, subfield:, record:)
       record.fields(tag).flat_map do |field|
@@ -130,24 +128,43 @@ module PennMARC
       end
     end
 
-    # @param [Symbol|String] trailer to target for removal
-    # @param [String] string to modify
+    # Trim punctuation method extracted from Traject macro, to ensure consistent output
+    # @param string [String]
+    # @return [String] string with relevant punctuation removed
+    def trim_punctuation(string)
+      return string unless string
+
+      string = string.sub(%r{ *[ ,/;:] *\Z}, '')
+
+      # trailing period if it is preceded by at least three letters (possibly preceded and followed by whitespace)
+      string = string.sub(/( *[[:word:]]{3,})\. *\Z/, '\1')
+
+      # single square bracket characters if they are the start and/or end chars and there are no internal square
+      # brackets.
+      string = string.sub(/\A\[?([^\[\]]+)\]?\Z/, '\1')
+
+      # trim any leading or trailing whitespace
+      string.strip
+    end
+
+    # @param trailer [Symbol|String] to target for removal
+    # @param string [String] to modify
     # @return [String]
     def trim_trailing(trailer, string)
       string.sub TRAILING_PUNCTUATIONS_PATTERNS[trailer.to_sym], ''
     end
 
     # trim trailing punctuation, manipulating string in place
-    # @param [Symbol|String] trailer to target for removal
-    # @param [String] string to modify
+    # @param trailer [Symbol|String] to target for removal
+    # @param string [String] to modify
     # @return [String, Nil] string to modify
     def trim_trailing!(trailer, string)
       string.sub! TRAILING_PUNCTUATIONS_PATTERNS[trailer.to_sym], ''
     end
 
     # Intelligently append given punctuation to the end of a string
-    # @param [Symbol] trailer
-    # @param [String] string
+    # @param trailer [Symbol]
+    # @param string [String]
     # @return [String]
     def append_trailing(trailer, string)
       return string if string.end_with?('.', '-')
@@ -165,9 +182,9 @@ module PennMARC
     # translations of title values. A common need is to extract subfields as selected by
     # passed-in block from 880 datafield that has a particular subfield 6 value.
     # See: https://www.loc.gov/marc/bibliographic/bd880.html
-    # @param [MARC::Record] record
-    # @param [String|Array] subfield6_value either a string to look for in sub6 or an array of them
-    # @param [Proc] selector takes a subfield as argument, returns a boolean
+    # @param record [MARC::Record]
+    # @param subfield6_value [String|Array] either a string to look for in sub6 or an array of them
+    # @param selector [Proc] takes a subfield as argument, returns a boolean
     # @return [Array] array of linked alternates
     def linked_alternate(record, subfield6_value, &selector)
       record.fields('880').filter_map do |field|
@@ -180,8 +197,8 @@ module PennMARC
     # Common case of wanting to extract all the subfields besides 6 or 8,
     # from 880 datafield that has a particular subfield 6 value. We exclude 6 because
     # that value is the linkage ID itself and 8 because... IDK
-    # @param [MARC::Record] record
-    # @param [String|Array] subfield6_value either a string to look for in sub6 or an array of them
+    # @param record [MARC::Record]
+    # @param subfield6_value [String|Array] either a string to look for in sub6 or an array of them
     # @return [Array] array of linked alternates without 8 or 6 values
     def linked_alternate_not_6_or_8(record, subfield6_value)
       excluded_subfields = %w[6 8]
@@ -191,8 +208,8 @@ module PennMARC
     end
 
     # Returns the non-6,8 subfields from a datafield and its 880 link.
-    # @param [MARC::Record] record
-    # @param [String] tag
+    # @param record [MARC::Record]
+    # @param tag [String]
     # @return [Array<String>] values
     def datafield_and_linked_alternate(record, tag)
       record.fields(tag).filter_map { |field|
@@ -201,23 +218,23 @@ module PennMARC
     end
 
     # Get the substring of a string up to a given target character
-    # @param [Object] string to split
-    # @param [Object] target character to split upon
+    # @param string [Object] to split
+    # @param target [Object] character to split upon
     # @return [String (frozen)]
     def substring_before(string, target)
       string.scan(target).present? ? string.split(target, 2).first : ''
     end
 
     # Get the substring of a string after the first occurrence of a target character
-    # @param [Object] string to split
-    # @param [Object] target character to split upon
+    # @param string [Object] to split
+    # @param target [Object] character to split upon
     # @return [String (frozen)]
     def substring_after(string, target)
       string.scan(target).present? ? string.split(target, 2).second : ''
     end
 
     # Join array and normalizing extraneous spaces
-    # @param [Array] array
+    # @param array [Array]
     # @return [String]
     def join_and_squish(array)
       array.join(' ').squish
@@ -225,7 +242,7 @@ module PennMARC
 
     # If there's a subfield i, extract its value, and if there's something
     # in parentheses in that value, extract that.
-    # @param [MARC::Field] field
+    # @param field [MARC::Field]
     # @return [String] subfield i without parentheses value
     def remove_paren_value_from_subfield_i(field)
       val = field.filter_map { |sf|
@@ -243,19 +260,19 @@ module PennMARC
 
     # Translate a relator code using mapping
     # @todo handle case of receiving a URI? E.g., http://loc.gov/relator/aut
-    # @param [String, NilClass] relator_code
-    # @param [Hash] mapping
+    # @param relator_code [String, NilClass]
+    # @param mapping [Hash]
     # @return [String, NilClass] full relator string
     def translate_relator(relator_code, mapping)
       return if relator_code.blank?
 
-      mapping[relator_code.to_sym]
+      mapping[relator_code&.to_sym]
     end
 
     # Get 650 & 880 for Provenance and Chronology: prefix should be 'PRO' or 'CHR' and may be preceded by a '%'
     # @note 11/2018: do not display $5 in PRO or CHR subjs
-    # @param [MARC::Record] record
-    # @param [String] prefix to select from subject field
+    # @param record [MARC::Record]
+    # @param prefix [String] to select from subject field
     # @return [Array] array of values
     def prefixed_subject_and_alternate(record, prefix)
       record.fields(%w[650 880]).filter_map { |field|
@@ -273,16 +290,16 @@ module PennMARC
 
     # Does the given field specify an allowed source code?
     #
-    # @param [MARC::DataField] field
+    # @param field [MARC::DataField]
     # @return [Boolean]
     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]
+    # @param field [MARC::Field]
+    # @param tags [Array<String>]
+    # @return [Boolean]
     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('|')})/)
@@ -291,7 +308,7 @@ module PennMARC
     end
 
     # Match any open dates ending a given string to determine join separator for relator term in 1xx/7xx fields.
-    # @param [String] str
+    # @param str [String]
     # @return [String (frozen)]
     def relator_join_separator(str)
       /\b\d+-\z/.match?(str) ? ' ' : ', '
@@ -302,7 +319,7 @@ module PennMARC
     # {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
+    # @param field [MARC:Field]
     # @return [String (frozen)]
     def relator_term_subfield(field)
       field_or_its_linked_alternate?(field, %w[111 411 611 711 811]) ? 'j' : 'e'
@@ -311,10 +328,10 @@ module PennMARC
     # 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
+    # @param field [MARC::Field] where relator values are stored
+    # @param joined_subfields [String] the string to which the relator is appended
+    # @param relator_term_sf [String] MARC subfield that stores relator term
+    # @param relator_map [Hash]
     # @return [String]
     def append_relator(field:, joined_subfields:, relator_term_sf:, relator_map: Mappers.relator)
       joined_subfields = trim_trailing(:comma, joined_subfields)
@@ -329,5 +346,17 @@ module PennMARC
 
       [joined_subfields, relator].compact_blank.join(join_separator).squish
     end
+
+    # Returns a relator value of the given field. Like append_relator, it prioritizes relator codes found in subfileld
+    # $4 and falls back to the specified relator term subfield relator_term_sf if no valid codes are found in $4
+    # @param [MARC::Field] field where relator values are stored
+    # @param [String] relator_term_sf MARC subfield that stores relator term
+    # @param [Hash] relator_map
+    # @return [String]
+    def relator(field:, relator_term_sf:, relator_map: Mappers.relator)
+      relator = subfield_values(field, '4').filter_map { |code| translate_relator(code, relator_map) }
+      relator = subfield_values(field, relator_term_sf) if relator.blank?
+      relator.join
+    end
   end
 end

data/lib/pennmarc/version.rb

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

data/lib/pennmarc.rb

@@ -2,5 +2,12 @@
 
 $LOAD_PATH.unshift(__dir__) unless $LOAD_PATH.include?(__dir__)
 
+module PennMARC
+  # Autoload MARC helpers
+  module Test
+    autoload :MarcHelpers, 'pennmarc/test/marc_helpers'
+  end
+end
+
 require_relative 'pennmarc/parser'
 require 'library_stdnums'

data/pennmarc.gemspec

@@ -10,7 +10,7 @@ Gem::Specification.new do |s|
   s.summary     = 'Penn Libraries Catalog MARC parsing wisdom for cross-project usage'
   s.description = 'This gem provides methods for parsing a Penn Libraries MARCXML record into string, array and date
                    objects for use in discovery or preservation applications.'
-  s.authors     = ['Mike Kanning', 'Amrey Mathurin', 'Patrick Perkins']
+  s.authors     = ['Mike Kanning', 'Amrey Mathurin', 'Patrick Perkins', 'Katherine Schultz', 'Baowei Wei']
   s.email       = 'mkanning@upenn.edu'
   s.files       = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
   s.homepage    = 'https://gitlab.library.upenn.edu/dld/catalog/pennmarc'
@@ -21,6 +21,7 @@ Gem::Specification.new do |s|
   s.add_dependency 'activesupport', '~> 7'
   s.add_dependency 'library_stdnums', '~> 1.6'
   s.add_dependency 'marc', '~> 1.2'
+  s.add_dependency 'multi_string_replace', '~> 2.0'
   s.add_dependency 'nokogiri', '~> 1.15'
 
   s.metadata['rubygems_mfa_required'] = 'false'

data/spec/lib/pennmarc/heading_control_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+describe 'PennMARC::HeadingControl' do
+  let(:replace_term) { PennMARC::Mappers.heading_overrides.first[0] }
+  let(:replaced_term) { PennMARC::Mappers.heading_overrides.first[1] }
+  let(:remove_term) { PennMARC::Mappers.headings_to_remove.first }
+
+  describe '.process' do
+    context 'with a term for removal' do
+      it 'removes the term if found in isolation' do
+        values = [remove_term]
+        expect(PennMARC::HeadingControl.term_override(values)).to eq []
+      end
+
+      it 'removes the term regardless of case' do
+        values = [remove_term.downcase]
+        expect(PennMARC::HeadingControl.term_override(values)).to eq []
+      end
+
+      it 'removes the term if it is included as a substring' do
+        values = ["#{remove_term}--History"]
+        expect(PennMARC::HeadingControl.term_override(values)).to eq []
+      end
+    end
+
+    context 'with a term for replacement' do
+      it 'replaces the term in isolation' do
+        values = [replace_term]
+        expect(PennMARC::HeadingControl.term_override(values)).to eq [replaced_term]
+      end
+
+      it 'replaces the term when used with other headings' do
+        values = ["#{replace_term}--History"]
+        expect(PennMARC::HeadingControl.term_override(values)).to eq ["#{replaced_term}--History"]
+      end
+    end
+
+    context 'with a variety of terms' do
+      it 'removes and replaces terms as needed' do
+        values = [remove_term, replace_term, 'History']
+        expect(PennMARC::HeadingControl.term_override(values)).to contain_exactly 'History', replaced_term
+      end
+    end
+  end
+end

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 describe 'PennMARC::Access' do
-  include MarcSpecHelpers
-
   let(:helper) { PennMARC::Access }
 
   describe '.facet' do

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 describe 'PennMARC::Citation' do
-  include MarcSpecHelpers
-
   let(:helper) { PennMARC::Citation }
 
   describe '.cited_in_show' do

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 describe 'PennMARC::Classification' do
-  include MarcSpecHelpers
-
   let(:helper) { PennMARC::Classification }
   let(:record) do
     marc_record fields: [marc_field(tag: tag,

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 describe 'PennMARC::Creator' do
-  include MarcSpecHelpers
-
   let(:helper) { PennMARC::Creator }
   let(:mapping) { { aut: 'Author' } }
 
@@ -95,6 +93,91 @@ describe 'PennMARC::Creator' do
     end
   end
 
+  describe '.authors_list' do
+    let(:record) { marc_record fields: fields }
+
+    context 'with two author records' 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: '700', subfields: { a: 'Surname, Alternative', '6': '100', d: '1970-' })]
+      end
+
+      it 'returns single author values with no URIs anywhere' do
+        values = helper.authors_list(record)
+        expect(values).to contain_exactly 'Surname, Name', 'Surname, Alternative'
+      end
+    end
+
+    context 'with three author records - abbreviated names' do
+      let(:fields) do
+        [marc_field(tag: '100', subfields: { a: 'Surname, Alex', '0': 'http://cool.uri/12345', d: '1900-2000',
+                                             e: 'author.', '4': 'http://cool.uri/vocabulary/relators/aut' }),
+         marc_field(tag: '110', subfields: { a: 'Second, NameX', '0': 'http://cool.uri/12345', d: '1901-2010',
+                                             e: 'author.', '4': 'http://cool.uri/vocabulary/relators/aut' }),
+         marc_field(tag: '700', subfields: { a: 'Alt, Alternative', '6': '100', d: '1970-' })]
+      end
+
+      it 'returns single author values with no URIs anywhere' do
+        values = helper.authors_list(record, first_initial_only: true)
+        expect(values).to contain_exactly 'Surname, A.', 'Second, N.', 'Alt, A.'
+      end
+    end
+  end
+
+  describe '.contributors_list' do
+    let(:record) { marc_record fields: fields }
+
+    context 'with two authors and four contributors records, names only' do
+      let(:fields) do
+        [marc_field(tag: '100', subfields: { a: 'Hamilton, Alex', '0': 'http://cool.uri/12345', d: '1900-2000',
+                                             e: 'author.' }),
+         marc_field(tag: '100', subfields: { a: 'Lincoln, Abraham', 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: 'Einstein, Albert', '6': '100', d: '1970-', '4': 'trl',
+                                             e: 'translator' }),
+         marc_field(tag: '700', subfields: { a: 'Franklin, Ben', '6': '100', d: '1970-', '4': 'edt' }),
+         marc_field(tag: '710', subfields: { a: 'Jefferson, Thomas', '6': '100', d: '1870-', '4': 'edt' }),
+         marc_field(tag: '700', subfields: { a: 'Dickens, Charles', '6': '100', d: '1970-', '4': 'com' })]
+      end
+
+      it 'returns two authors and four contributors' do
+        values = helper.contributors_list(record)
+        expect(values).to contain_exactly ['Author', ['Hamilton, Alex', 'Lincoln, Abraham']],
+                                          ['Compiler', ['Dickens, Charles']],
+                                          ['Editor', ['Franklin, Ben', 'Jefferson, Thomas']],
+                                          ['Translator', ['Einstein, Albert']]
+      end
+    end
+
+    context 'with two authors and four contributors records, with full information and relator' do
+      let(:fields) do
+        [marc_field(tag: '100', subfields: { a: 'Hamilton, Alex', '0': 'http://cool.uri/12345', d: '1900-2000',
+                                             e: 'author.', '4': 'aut' }),
+         marc_field(tag: '100', subfields: { a: 'Lincoln, Abraham', 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: 'Einstein, Albert', '6': '100', d: '1970-', '4': 'trl',
+                                             e: 'translator' }),
+         marc_field(tag: '700', subfields: { a: 'Franklin, Ben', '6': '100', d: '1970-', '4': 'edt' }),
+         marc_field(tag: '710', subfields: { a: 'Jefferson, Thomas', '6': '100', d: '1870-', '4': 'edt' }),
+         marc_field(tag: '700', subfields: { a: 'Dickens, Charles', '6': '100', d: '1970-', '4': 'com' }),
+         marc_field(tag: '880', subfields: { a: '狄更斯', '6': '700', d: '1970-', '4': 'com' }),
+         marc_field(tag: '700', subfields: { a: 'Twain, Mark', '6': '100', d: '1870-' })]
+      end
+
+      it 'returns four contributors' do
+        values = helper.contributors_list(record, include_authors: false, name_only: false, vernacular: true)
+        expect(values).to contain_exactly ['Compiler', ['Dickens, Charles 1970-, Compiler', '狄更斯 1970-, Compiler']],
+                                          ['Contributor', ['Twain, Mark 1870-, Contributor']],
+                                          ['Editor',
+                                           ['Franklin, Ben 1970-, Editor', 'Jefferson, Thomas 1870-, Editor']],
+                                          ['Translator', ['Einstein, Albert 1970-, Translator']]
+      end
+    end
+  end
+
   describe '.show_facet_map' do
     let(:record) do
       marc_record fields: [
@@ -302,6 +385,24 @@ describe 'PennMARC::Creator' do
     end
   end
 
+  describe '.corporate_search' do
+    let(:record) do
+      marc_record fields: [
+        marc_field(tag: '110', subfields: { a: 'Penn Libraries', b: 'Digital Library Development' }),
+        marc_field(tag: '710', subfields: { a: 'Working Group on Digital Repository Infrastructure' }),
+        marc_field(tag: '810', subfields: { a: 'Constellation of Repositories Strategic Team' })
+      ]
+    end
+
+    it 'returns expected values' do
+      expect(helper.corporate_search(record)).to contain_exactly(
+        'Constellation of Repositories Strategic Team',
+        'Penn Libraries Digital Library Development',
+        'Working Group on Digital Repository Infrastructure'
+      )
+    end
+  end
+
   describe '.contributor_show' do
     let(:record) { marc_record fields: fields }
 

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 describe 'PennMARC::Database' do
-  include MarcSpecHelpers
-
   let(:helper) { PennMARC::Database }
   let(:record) do
     marc_record(fields: [

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 describe 'PennMARC::Date' do
-  include MarcSpecHelpers
-
   let(:helper) { PennMARC::Date }
   let(:record) { marc_record fields: fields }
 

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 describe 'PennMARC::Edition' do
-  include MarcSpecHelpers
-
   let(:helper) { PennMARC::Edition }
   let(:mapping) { { aut: 'Author' } }
   let(:record) do
@@ -18,6 +16,10 @@ describe 'PennMARC::Edition' do
     it 'returns the editions' do
       expect(helper.show(record)).to contain_exactly('5th Edition Remastered', 'رمستر')
     end
+
+    it 'returns the editions without alternate' do
+      expect(helper.show(record, with_alternate: false)).to contain_exactly('5th Edition Remastered')
+    end
   end
 
   describe '.values' do

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 describe 'PennMARC::Format' do
-  include MarcSpecHelpers
-
   let(:helper) { PennMARC::Format }
 
   describe '.facet' do

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 describe 'PennMARC::Genre' do
-  include MarcSpecHelpers
-
   let(:helper) { PennMARC::Genre }
   let(:record) { marc_record fields: fields }
 

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

@@ -1,8 +1,6 @@
 # frozen_string_literal: true
 
 describe 'PennMARC::Identifier' do
-  include MarcSpecHelpers
-
   let(:helper) { PennMARC::Identifier }
 
   describe '.mmsid' do