pennmarc 1.0.25 → 1.0.26

data/lib/pennmarc/helpers/production.rb

@@ -4,31 +4,47 @@ module PennMARC
   # Extracts data related to a resource's production, distribution, manufacture, and publication.
   class Production < Helper
     class << self
-      # Retrieve production values for display from {https://www.oclc.org/bibformats/en/2xx/264.html 264 field}.
-      # @param [MARC::Record] record
+      # Retrieve production values for display from {https://www.loc.gov/marc/bibliographic/bd264.html 264 field}.
+      # @param record [MARC::Record]
       # @return [Array<String>]
       def show(record)
         get_264_or_880_fields(record, '0').uniq
       end
 
-      # Retrieve distribution values for display from {https://www.oclc.org/bibformats/en/2xx/264.html 264 field}.
-      # @param [MARC::Record] record
+      # Retrieve production values for searching. Includes only
+      # {https://www.loc.gov/marc/bibliographic/bd260.html 260} and
+      # {https://www.loc.gov/marc/bibliographic/bd264.html 264}.
+      # @param record [MARC::Record]
+      # @return [Array<String>]
+      def search(record)
+        values = record.fields('260').filter_map do |field|
+          join_subfields(field, &subfield_in?(['b']))
+        end
+        values + record.fields('264').filter_map { |field|
+          next unless field.indicator2 == '1'
+
+          join_subfields(field, &subfield_in?(['b']))
+        }.uniq
+      end
+
+      # Retrieve distribution values for display from {https://www.loc.gov/marc/bibliographic/bd264.html 264 field}.
+      # @param record [MARC::Record]
       # @return [Array<String>]
       def distribution_show(record)
         get_264_or_880_fields(record, '2').uniq
       end
 
-      # Retrieve manufacture values for display from {https://www.oclc.org/bibformats/en/2xx/264.html 264 field}.
-      # @param [MARC::Record] record
+      # Retrieve manufacture values for display from {https://www.loc.gov/marc/bibliographic/bd264.html 264 field}.
+      # @param record [MARC::Record]
       # @return [Array<String>]
       def manufacture_show(record)
         get_264_or_880_fields(record, '3').uniq
       end
 
       # Retrieve publication values. Return publication values from
-      # {https://www.oclc.org/bibformats/en/2xx/264.html 264 field} only if none found
-      # {https://www.oclc.org/bibformats/en/2xx/260.html 260}-262 fields.
-      # @param [MARC::Record] record
+      # {https://www.loc.gov/marc/bibliographic/bd264.html 264 field} only if none found
+      # {https://www.loc.gov/marc/bibliographic/bd260.html 260}-262 fields.
+      # @param record [MARC::Record]
       # @return [Array<String>]
       def publication_values(record)
         # first get inclusive dates
@@ -64,10 +80,10 @@ module PennMARC
       end
 
       # Retrieve publication values for display from fields
-      # {https://www.oclc.org/bibformats/en/2xx/245.html 245},
-      # {https://www.oclc.org/bibformats/en/2xx/260.html 260}-262 and their linked alternates,
-      # and {https://www.oclc.org/bibformats/en/2xx/264.html 264} and its linked alternate.
-      # @param [MARC::Record] record
+      # {https://www.loc.gov/marc/bibliographic/bd245.html 245},
+      # {https://www.loc.gov/marc/bibliographic/bd260.html 260}-262 and their linked alternates,
+      # and {https://www.loc.gov/marc/bibliographic/bd264.html 264} and its linked alternate.
+      # @param record [MARC::Record]
       # @return [Array<String>]
       def publication_show(record)
         values = record.fields('245').first(1).flat_map { |field| subfield_values(field, 'f') }
@@ -89,10 +105,49 @@ module PennMARC
         values.compact_blank.uniq
       end
 
-      # Retrieve place of publication for display from {https://www.oclc.org/bibformats/en/7xx/752.html 752 field} and
+      # Retrieve publication values for citation
+      # {https://www.loc.gov/marc/bibliographic/bd245.html 245},
+      # {https://www.loc.gov/marc/bibliographic/bd260.html 260}-262 and their linked alternates,
+      # and {https://www.loc.gov/marc/bibliographic/bd264.html 264} and its linked alternate.
+      # @param [MARC::Record] record
+      # @param [Boolean] with_year: return results with publication year if true
+      # @return [Array<String>]
+      def publication_citation_show(record, with_year: true)
+        values = record.fields('245').first(1).flat_map { |field| subfield_values(field, 'f') }
+
+        subfields = with_year ? %w[6 8] : %w[6 8 c]
+        values += record.fields(%w[260 261 262]).first(1).map do |field|
+          join_subfields(field, &subfield_not_in?(subfields))
+        end
+
+        subfields = with_year ? %w[a b c] : %w[a b]
+        values += record.fields('264').filter_map do |field|
+          next unless field.indicator2 == '1'
+
+          join_subfields(field, &subfield_in?(subfields))
+        end
+
+        values.compact_blank.uniq
+      end
+
+      # Returns the place of publication for RIS
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def publication_ris_place_of_pub(record)
+        get_publication_ris_values(record, 'a')
+      end
+
+      # Returns the publisher for RIS
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def publication_ris_publisher(record)
+        get_publication_ris_values(record, 'b')
+      end
+
+      # Retrieve place of publication for display from {https://www.loc.gov/marc/bibliographic/bd752.html 752 field} and
       # its linked alternate.
       # @note legacy version returns array of hash objects including data for display link
-      # @param [MARC::Record] record
+      # @param record [MARC::Record]
       # @return [Array<String>]
       def place_of_publication_show(record)
         record.fields(%w[752 880]).filter_map { |field|
@@ -104,13 +159,32 @@ module PennMARC
         }.uniq
       end
 
+      # Retrieves place of publication values for searching. Includes
+      # {https://www.loc.gov/marc/bibliographic/bd752.html 752} as well as sf a from
+      # {https://www.loc.gov/marc/bibliographic/bd260.html 260} and
+      # {https://www.loc.gov/marc/bibliographic/bd264.html 264} with an indicator2 of 1.
+      # @param record [MARC::Record]
+      # @return [Array<String>]
+      def place_of_publication_search(record)
+        values = record.fields('260').filter_map do |field|
+          join_subfields(field, &subfield_in?(['a']))
+        end
+        values += record.fields('264').filter_map do |field|
+          next unless field.indicator2 == '1'
+
+          join_subfields(field, &subfield_in?(['a']))
+        end
+        values + record.fields('752').filter_map { |field|
+          join_subfields(field, &subfield_in?(%w[a b c d f g h]))
+        }.uniq
+      end
+
       private
 
-      # base method to retrieve production values from {https://www.oclc.org/bibformats/en/2xx/264.html 264 field} based
-      # on indicator2.
-      # distribution and manufacture share the same logic except for indicator2
-      # @param [MARC::Record] record
-      # @param [String] indicator2
+      # base method to retrieve production values from {https://www.loc.gov/marc/bibliographic/bd264.html 264 field}
+      # based on indicator2. "Distribution" and "manufacture" share the same logic except for indicator2.
+      # @param record [MARC::Record]
+      # @param indicator2 [String]
       # @return [Array<String>]
       def get_264_or_880_fields(record, indicator2)
         values = record.fields('264').filter_map do |field|
@@ -126,6 +200,25 @@ module PennMARC
           join_subfields(field, &subfield_in?(%w[a b c]))
         end
       end
+
+      # Returns the publication value of the given subfield
+      # @param [MARC::Record] record
+      # @param [String] subfield
+      def get_publication_ris_values(record, subfield)
+        values = record.fields('245').first(1).flat_map { |field| subfield_values(field, 'f') }
+
+        values += record.fields(%w[260 261 262]).first(1).map do |field|
+          join_subfields(field, &subfield_in?([subfield]))
+        end
+
+        values += record.fields('264').filter_map do |field|
+          next unless field.indicator2 == '1'
+
+          join_subfields(field, &subfield_in?([subfield]))
+        end
+
+        values.compact_blank.uniq
+      end
     end
   end
 end

data/lib/pennmarc/test/marc_helpers.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'nokogiri'
+require 'marc'
+
+module PennMARC
+  module Test
+    # Helper methods for use in constructing MARC objects for testing
+    module MarcHelpers
+      # Return a MARC::XMLReader that will parse a given file and return MARC::Record objects
+      # @param [String] filename of MARCXML fixture
+      # @return [MARC::Record, NilClass]
+      def record_from(filename)
+        MARC::XMLReader.new(marc_xml_path(filename)).first
+      end
+
+      # Create an isolated MARC::Subfield object for use in specs or as part of a MARC::Field
+      # @param [String] code
+      # @param [String] value
+      # @return [MARC::Subfield]
+      def marc_subfield(code, value)
+        MARC::Subfield.new code.to_s, value
+      end
+
+      # Return a new ControlField (000-009)
+      # @param [String] tag
+      # @param [String] value
+      # @return [MARC::ControlField]
+      def marc_control_field(tag:, value:)
+        MARC::ControlField.new tag, value
+      end
+
+      # Create an isolated MARC::DataField object for use in specs
+      # Can pass in tag, indicators and subfields (using simple hash structure). E.g.,
+      # marc_field(tag: '650', indicator2: '7'),
+      #            subfields: { a: 'Tax planning',
+      #                         m: ['Multiple', 'Subfields']
+      #                         z: 'United States.',
+      #                         '0': http://id.loc.gov/authorities/subjects/sh2008112546 }
+      #            )
+      # @param [String (frozen)] tag MARC tag, e.g., 001, 665
+      # @param [String (frozen)] indicator1 MARC indicator, e.g., 0
+      # @param [String (frozen)] indicator2
+      # @param [Hash] subfields hash of subfield values as code => value or code => [value, value]
+      # @return [MARC::DataField]
+      def marc_field(tag: 'TST', indicator1: ' ', indicator2: ' ', subfields: {})
+        subfield_objects = subfields.each_with_object([]) do |(code, value), array|
+          Array.wrap(value).map { |v| array << marc_subfield(code, v) }
+        end
+        MARC::DataField.new tag, indicator1, indicator2, *subfield_objects
+      end
+
+      # Return a MARC::Record containing passed in DataFields
+      # @param [Array<MARC::DataField>] fields
+      # @param [String, nil] leader
+      # @return [MARC::Record]
+      def marc_record(fields: [], leader: nil)
+        record = MARC::Record.new
+        fields.each { |field| record << field }
+        record.leader = leader if leader
+        record
+      end
+
+      # Mock map for location lookup using Location helper
+      # The location codes :dent and :stor are the two outermost keys
+      # :specific_location, :library, :display are the inner keys that store location values
+      # @example
+      #   location_map[:stor][:library] #=> 'LIBRA'
+      # @return [Hash]
+      def location_map
+        { dent: {  specific_location: 'Levy Dental Medicine Library - Stacks',
+                   library: ['Health Sciences Libraries', 'Levy Dental Medicine Library'],
+                   display: 'Levy Dental Medicine Library - Stacks' },
+          stor: { specific_location: 'LIBRA',
+                  library: 'LIBRA',
+                  display: 'LIBRA' },
+          vanp: { specific_location: 'Van Pelt - Stacks',
+                  library: 'Van Pelt-Dietrich Library Center',
+                  display: 'Van Pelt Library' } }
+      end
+    end
+  end
+end

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.26'
 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/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