pennmarc 1.0.0 → 1.0.1

data/legacy/marc.rb

@@ -1,2964 +0,0 @@
-# rubocop:disable all
-# frozen_string_literal: true
-
-require 'nokogiri'
-
-module PennLib
-
-  # Constants for Alma's MARC enrichment
-  module EnrichedMarc
-    # terminology follows the Publishing Profile screen
-    TAG_HOLDING = 'hld'
-    TAG_ITEM = 'itm'
-    TAG_ELECTRONIC_INVENTORY = 'prt'
-    TAG_DIGITAL_INVENTORY = 'dig'
-
-    # these are 852 subfield codes; terminology comes from MARC spec
-    SUB_HOLDING_SHELVING_LOCATION = 'c'
-    SUB_HOLDING_SEQUENCE_NUMBER = '8'
-    SUB_HOLDING_CLASSIFICATION_PART = 'h'
-    SUB_HOLDING_ITEM_PART = 'i'
-
-    SUB_ITEM_CURRENT_LOCATION = 'g'
-    SUB_ITEM_CALL_NUMBER_TYPE = 'h'
-    SUB_ITEM_CALL_NUMBER = 'i'
-    SUB_ITEM_DATE_CREATED = 'q'
-
-    SUB_ELEC_PORTFOLIO_PID = 'a'
-    SUB_ELEC_ACCESS_URL = 'b'
-    SUB_ELEC_COLLECTION_NAME = 'c'
-    SUB_ELEC_COVERAGE = 'g'
-
-    # a subfield code NOT used by the MARC 21 spec for 852 holdings records.
-    # we add this subfield during preprocessing to store boundwith record IDs.
-    SUB_BOUND_WITH_ID = 'y'
-  end
-
-  module DateType
-    # Nothing
-    UNSPECIFIED = '|'
-    NO_DATES_OR_BC = 'b'
-    UNKNOWN = 'n'
-
-    # Single point
-    DETAILED = 'e'
-    SINGLE = 's'
-
-    # Lower bound
-    CONTINUING_CURRENTLY_PUBLISHED = 'c'
-    CONTINUING_STATUS_UNKNOWN = 'u'
-
-    # Range
-    CONTINUING_CEASED_PUBLICATION = 'd'
-    COLLECTION_INCLUSIVE = 'i'
-    COLLECTION_BULK = 'k'
-    MULTIPLE = 'm'
-    QUESTIONABLE = 'q'
-
-    # Separate date for content
-    DISTRIBUTION_AND_PRODUCTION = 'p'
-    REPRINT_AND_ORIGINAL = 'r'
-    PUBLICATION_AND_COPYRIGHT = 't'
-
-    MAP = {
-      DETAILED => :single,
-      SINGLE => :single,
-
-      CONTINUING_CURRENTLY_PUBLISHED => :lower_bound,
-      CONTINUING_STATUS_UNKNOWN => :lower_bound,
-
-      CONTINUING_CEASED_PUBLICATION => :range,
-      COLLECTION_INCLUSIVE => :range,
-      COLLECTION_BULK => :range,
-      MULTIPLE => :range,
-      QUESTIONABLE => :range,
-
-      DISTRIBUTION_AND_PRODUCTION => :separate_content,
-      REPRINT_AND_ORIGINAL => :separate_content,
-      PUBLICATION_AND_COPYRIGHT => :separate_content
-    }
-  end
-
-  module SubjectConfig
-
-    module Prefixes
-      NAME = 'n'
-      TITLE = 't'
-      SUBJECT = 's' # used for default, handled as lcsh
-      FAST = 'f'
-      GEO = 'g'
-      CHILDRENS = 'c'
-      MESH = 'm'
-      OTHER = 'o'
-    end
-
-    class FieldConfig
-      def initialize(mapper)
-        @mapper = mapper
-      end
-
-      def map_prefix(field)
-        @mapper.call(field)
-      end
-    end
-
-    THESAURI = {
-      'aat' => Prefixes::OTHER,
-      'cct' => Prefixes::OTHER,
-      'fast' => Prefixes::FAST,
-      'homoit' => Prefixes::OTHER,
-      'jlabsh' => Prefixes::OTHER,
-      'lcsh' => Prefixes::SUBJECT,
-      'lcstt' => Prefixes::OTHER,
-      'lctgm' => Prefixes::OTHER,
-      'local/osu' => Prefixes::OTHER,
-      'mesh' => Prefixes::MESH,
-      'ndlsh' => Prefixes::OTHER,
-      'nlksh' => Prefixes::OTHER
-    }
-
-    # default field mapping is based only on ind2, and topic headings (as
-    # opposed to name/title headings) vary significantly across thesauri
-    default_field_mapping = FieldConfig.new(lambda { |f|
-      case f.indicator2
-      when '0'
-        return Prefixes::SUBJECT
-      when '1'
-        return Prefixes::CHILDRENS
-      when '2'
-        return Prefixes::MESH
-      when '4'
-        return Prefixes::OTHER
-      else
-        return nil
-      end
-    })
-
-    # for name/title, ind2=='0'/'1'/'2' are _all_ backed by LCNAF. See:
-    # https://www.loc.gov/aba/cyac/childsubjhead.html
-    # https://www.nlm.nih.gov/tsd/cataloging/trainingcourses/mesh/mod8_020.html
-    base_factory = lambda { |base|
-      lambda { |f|
-        case f.indicator2
-        when '0', '1', '2'
-          return base
-        when '4'
-          return Prefixes::OTHER
-        else
-          return nil
-        end
-      }
-    }
-    name_general = FieldConfig.new(base_factory.call(Prefixes::NAME))
-    title_general = FieldConfig.new(base_factory.call(Prefixes::TITLE))
-    geo_general = FieldConfig.new(base_factory.call(Prefixes::GEO))
-    static_other = FieldConfig.new(lambda { |f|
-      # For now, treat all of these as "other"
-      case f.indicator2
-      when '0', '1', '2', '4'
-        # NOTE: 2nd indicator for local subject fields is inconsistently applied; map everything to "other"
-        return Prefixes::OTHER
-      else
-        return nil
-      end
-    })
-
-    FIELDS = {
-      '600' => name_general,
-      '610' => name_general,
-      '611' => name_general,
-      '630' => title_general,
-      '650' => default_field_mapping,
-      '651' => geo_general,
-      '690' => static_other, # topical (650)
-      '691' => static_other, # geographic (651)
-      #'696' => static_other  # personal name (600) NOTE: not currently mapped!
-      '697' => static_other  # corporate name (610)
-    }
-
-    def self.prepare_subjects(rec)
-      acc = []
-      rec.fields(FIELDS.keys).each do |f|
-        filter_subject(f, f.tag, acc)
-      end
-      rec.fields('880').each do |f|
-        field_type_tag = f.find { |sf| sf.code == '6' && FIELDS.has_key?(sf.value) }&.value
-        filter_subject(f, field_type_tag, acc) if field_type_tag
-      end
-      return acc.empty? ? nil : map_to_input_fields(acc)
-    end
-
-    ONLY_KEYS = [:val, :prefix, :append, :local, :vernacular]
-
-    def self.map_to_input_fields(acc)
-      xfacet = [] # provisionally instantiate; we'll almost always need it
-      ret = {
-        # `xfacets` entries support browse/facet, and will be mapped to stored fields solr-side
-        xfacet: nil,
-        # `stored_*` fields (below) are stored only, and do _not_ support browse/facet
-        stored_lcsh: nil,
-        stored_childrens: nil,
-        stored_mesh: nil,
-        stored_local: nil
-      }
-      acc.each do |struct|
-        last = struct[:parts].last
-        # Normalize trailing punctuation on the last heading component. If a comma is present (to be
-        # normalized away), then any `.` present is integral (i.e., not ISBD punctuation), and thus
-        # should be left intact as part of the heading.
-        Marc.trim_trailing_comma!(last) || Marc.trim_trailing_period!(last)
-        if struct[:local] && struct[:prefix] == Prefixes::OTHER
-          # local subjects without source specified are really too messy, so they should bypass
-          # xfacet processing and be placed directly in stored field for display only
-          struct[:val] = struct.delete(:parts).join('--')
-          struct.delete(:prefix)
-          serialized = struct.to_json(:only => ONLY_KEYS)
-          (ret[:stored_local] ||= []) << serialized
-        elsif struct.size == 2
-          # only `parts` and `prefix` (required keys) are present; use legacy format (for now
-          # we're mainly doing this to incidentally test backward compatibility of server-side
-          # parsing
-          serialized = struct[:prefix] + struct[:parts].join('--')
-          xfacet << serialized
-        else
-          # simply map `parts` to `val`
-          struct[:val] = struct.delete(:parts).join('--')
-          serialized = struct.to_json(:only => ONLY_KEYS)
-          xfacet << serialized
-        end
-      end
-      ret[:xfacet] = xfacet unless xfacet.empty?
-      return ret
-    end
-
-    def self.filter_subject(field, tag, acc)
-      ret = build_subject_struct(field, tag)
-      return nil unless ret
-      return nil unless map_prefix(ret, tag, field)
-      acc << ret if post_process(ret)
-    end
-
-    def self.map_prefix(ret, tag, field)
-      if ret[:source_specified]
-        # source_specified takes priority. NOTE: This is true even if ind2!=7 (i.e., source_specified
-        # shouldn't even apply), because we want to be lenient with our parsing, so the priciple is that
-        # we defer to the _most explicit_ heading type declaration
-        prefix = THESAURI[ret[:source_specified].downcase]
-      else
-        # in the absence of `source_specified`, handling depends on field. NOTE: fields should be
-        # pre-filtered to only valid codes, so intentionally don't use the safe-nav operator here
-        prefix = FIELDS[tag].map_prefix(field)
-      end
-      prefix ? (ret[:prefix] = prefix) : nil
-    end
-
-    def self.build_subject_struct(field, tag)
-      local = field.indicator2 == '4' || tag.starts_with?('69')
-      ret = {
-        count: 0,
-        parts: [],
-      }
-      ret[:local] = true if local
-      ret[:vernacular] = true if field.tag == '880'
-      field.each do |sf|
-        case sf.code
-        when '0', '6', '8', '5', '1'
-          # ignore these subfields
-          next
-        when 'a'
-          # filter out PRO/CHR entirely (but only need to check on local heading types)
-          return nil if local && sf.value =~ /^%?(PRO|CHR)([ $]|$)/
-        when '2'
-          # use the _last_ source specified, so don't worry about overriding any prior values
-          ret[:source_specified] = sf.value.strip
-          next
-        when 'e', 'w'
-          # 'e' is relator term; not sure what 'w' is. These are used to append for record-view display only
-          (ret[:append] ||= []) << sf.value.strip
-          next
-        when 'b', 'c', 'd', 'p', 'q', 't'
-          # these are appended to the last component if possible (i.e., when joined, should have no delimiter)
-          append_to_last_part(ret[:parts], sf.value.strip)
-          ret[:count] += 1
-          next
-        end
-        # the usual case; add a new component to `parts`
-        append_new_part(ret[:parts], sf.value.strip)
-        ret[:count] += 1
-      end
-      return ret
-    end
-
-    def self.append_new_part(parts, value)
-      if parts.empty?
-        parts << value
-      else
-        last = parts.last
-        Marc.trim_trailing_comma!(last) || Marc.trim_trailing_period!(last)
-        parts << value
-      end
-    end
-
-    def self.append_to_last_part(parts, value)
-      if parts.empty?
-        parts << value
-      else
-        parts.last << ' ' + value
-      end
-    end
-
-    def self.post_process(ret)
-      case ret.delete(:count)
-      when 0
-        return nil
-      when 1
-        # when we've only encountered one subfield, assume that it might be a poorly-coded record
-        # with a bunch of subdivisions mashed together, and attempt to convert it to a consistent
-        # form. Note that we must separately track count (as opposed to simply checking `parts.size`),
-        # because we're using "subdivision count" as a heuristic for the quality level of the heading.
-        only = ret[:parts].first
-        only.gsub!(/([[[:alnum:]])])(\s+--\s*|\s*--\s+)([[[:upper:]][[:digit:]]])/, '\1--\3')
-        only.gsub!(/([[[:alpha:]])])\s+-\s+([[:upper:]]|[[:digit:]]{2,})/, '\1--\2')
-        only.gsub!(/([[[:alnum:]])])\s+-\s+([[:upper:]])/, '\1--\2')
-      end
-      return ret
-    end
-  end
-
-  module EncodingLevel
-    # Official MARC codes (https://www.loc.gov/marc/bibliographic/bdleader.html)
-    FULL = ' '
-    FULL_NOT_EXAMINED = '1'
-    UNFULL_NOT_EXAMINED = '2'
-    ABBREVIATED = '3'
-    CORE = '4'
-    PRELIMINARY = '5'
-    MINIMAL = '7'
-    PREPUBLICATION = '8'
-    UNKNOWN = 'u'
-    NOT_APPLICABLE = 'z'
-
-    # OCLC extension codes (https://www.oclc.org/bibformats/en/fixedfield/elvl.html)
-    OCLC_FULL = 'I'
-    OCLC_MINIMAL = 'K'
-    OCLC_BATCH_LEGACY = 'L'
-    OCLC_BATCH = 'M'
-    OCLC_SOURCE_DELETED = 'J'
-
-    RANK = {
-      # top 4 (per nelsonrr), do not differentiate among "good" records
-      FULL => 0,
-      FULL_NOT_EXAMINED => 0, # 1
-      OCLC_FULL => 0, # 2
-      CORE => 0, # 3
-      UNFULL_NOT_EXAMINED => 4,
-      ABBREVIATED => 5,
-      PRELIMINARY => 6,
-      MINIMAL => 7,
-      OCLC_MINIMAL => 8,
-      OCLC_BATCH => 9,
-      OCLC_BATCH_LEGACY => 10,
-      OCLC_SOURCE_DELETED => 11
-    }
-  end
-
-  # Genre/Form
-  # display field selector logic
-  # reference: https://www.loc.gov/marc/bibliographic/bd655.html
-  #
-  # We display Genre/Term values if they fulfill the following criteria
-  #  - The field is in MARC 655. Or the field is in MARC 880 with subfield 2 includes '655'.
-  #   AND
-  #    - Above fields have an indicator 2 value of: 0 (LSCH) or 4 (No source specified).
-  #     OR
-  #    - Above fields have a subfield 2 (ontology code) in the list of allowed values.
-  class GenreTools
-    GENRE_FIELD_TAG = '655'
-    ALT_GENRE_FIELD_TAG = '880'
-    ALLOWED_INDICATOR2_VALUES = %w[0 4]
-
-    class << self
-      # @param [MARC::DataField] field
-      # @return [TrueClass, FalseClass]
-      def allowed_genre_field?(field)
-        return false unless genre_field?(field)
-
-        allowed_code?(field) || allowed_ind2?(field)
-      end
-
-      # @param [MARC::DataField] field
-      # @return [TrueClass, FalseClass]
-      def genre_field?(field)
-        field.tag == GENRE_FIELD_TAG ||
-          (field.tag == ALT_GENRE_FIELD_TAG && MarcUtil.has_subfield_value?(field, '6', /#{GENRE_FIELD_TAG}/))
-      end
-
-      # @param [MARC::DataField] field
-      # @return [TrueClass, FalseClass]
-      def allowed_code?(field)
-        MarcUtil.subfield_value_in?(field, '2', PennLib::Marc::ALLOWED_SUBJ_GENRE_ONTOLOGIES)
-      end
-
-      # 0 in ind2 means LCSH
-      # 4 in ind2 means "Source not specified"
-      # @param [MARC::DataField] field
-      # @return [TrueClass, FalseClass]
-      def allowed_ind2?(field)
-        field.indicator2.in? ALLOWED_INDICATOR2_VALUES
-      end
-    end
-  end
-
-  # class to hold "utility" methods used by others methods in main Marc class and new *Tool classes
-  # for now, leave methods as also defined in Marc class to avoid unexpected issues
-  class MarcUtil
-    class << self
-      # returns true if field has a value that matches
-      # passed-in regex and passed in subfield
-      # @param [MARC::DataField] field
-      # @param [String|Integer|Symbol] subf
-      # @param [Regexp] regex
-      # @return [TrueClass, FalseClass]
-      def has_subfield_value?(field, subf, regex)
-        field.any? { |sf| sf.code == subf.to_s && sf.value =~ regex }
-      end
-
-      # @param [MARC:DataField] field
-      # @param [String|Integer|Symbol] subf
-      # @param [Array] array
-      # @return [TrueClass, FalseClass]
-      def subfield_value_in?(field, subf, array)
-        field.any? { |sf| sf.code == subf.to_s && sf.value.in?(array) }
-      end
-    end
-  end
-
-  # Class for doing extraction and processing on MARC::Record objects.
-  # This is intended to be used in both indexing code and front-end templating code
-  # (since MARC is stored in Solr). As such, there should NOT be any traject-specific
-  # things here.
-  #
-  # For a slight performance increase (~5%?) we use frozen_string_literal for immutable strings.
-  #
-  # Method naming conventions:
-  #
-  # *_values = indicates method returns an Array of values
-  #
-  # *_display = indicates method is intended to be used for
-  # individual record view (we should name things more meaningfully, according to
-  # the logic by which the values are generated, but I don't always know what this
-  # logic is, necessarily - JC)
-  #
-  class Marc
-    include BlacklightSolrplugins::Indexer
-
-    attr_accessor :code_mappings
-
-    DATABASES_FACET_VALUE = 'Database & Article Index'
-    ALLOWED_SUBJ_GENRE_ONTOLOGIES = %w[aat cct fast ftamc gmgpc gsafd homoit jlabsh lcgft lcsh lcstt lctgm
-                                       local/osu mesh ndlsh nlksh rbbin rbgenr rbmscv rbpap rbpri rbprov rbpub rbtyp]
-
-    # @param [PennLib::CodeMappings]
-    def initialize(code_mappings)
-      @code_mappings = code_mappings
-    end
-
-    def current_year
-      @current_year ||= Date.today.year
-    end
-
-    def relator_codes
-      @code_mappings.relator_codes
-    end
-
-    def locations
-      @code_mappings.locations
-    end
-
-    def loc_classifications
-      @code_mappings.loc_classifications
-    end
-
-    def dewey_classifications
-      @code_mappings.dewey_classifications
-    end
-
-    def languages
-      @code_mappings.languages
-    end
-
-    def trim_trailing_colon(s)
-      s.sub(/\s*:\s*$/, '')
-    end
-
-    def trim_trailing_semicolon(s)
-      s.sub(/\s*;\s*$/, '')
-    end
-
-    def trim_trailing_equal(s)
-      s.sub(/=$/, '')
-    end
-
-    def trim_trailing_slash(s)
-      s.sub(/\s*\/\s*$/, '')
-    end
-
-    def trim_trailing_comma(s)
-      self.class.trim_trailing_comma(s, false)
-    end
-
-    def self.trim_trailing_comma!(s)
-      trim_trailing_comma(s, true)
-    end
-
-    def self.trim_trailing_comma(s, inplace)
-      replace_regex = /\s*,\s*$/
-      inplace ? s.sub!(replace_regex, '') : s.sub(replace_regex, '')
-    end
-
-    def trim_trailing_period(s)
-      self.class.trim_trailing_period(s, false)
-    end
-
-    def self.trim_trailing_period!(s)
-      trim_trailing_period(s, true)
-    end
-
-    def self.trim_trailing_period(s, inplace)
-      if s.end_with?('etc.') || s =~ /(^|[^a-zA-Z])[A-Z]\.$/
-        inplace ? nil : s # nil if unchanged, for consistency with standard `inplace` semantics
-      else
-        replace_regex = /\.\s*$/
-        inplace ? s.sub!(replace_regex, '') : s.sub(replace_regex, '')
-      end
-    end
-
-    # squish in ActiveSupport
-    def normalize_space(s)
-      s.strip.gsub(/\s{2,}/, ' ')
-    end
-
-    # this logic matches substring-before in XSLT: if no match for sub, returns an empty string
-    def substring_before(s, sub)
-      s.scan(sub).present? ? s.split(sub, 2)[0] : ''
-    end
-
-    # this logic matches substring-after in XSLT: if no match for sub, returns an empty string
-    def substring_after(s, sub)
-      s.scan(sub).present? ? s.split(sub, 2)[1] : ''
-    end
-
-    def join_and_trim_whitespace(array)
-      normalize_space(array.join(' '))
-    end
-
-    # join subfield values together (as selected using passed-in block)
-    def join_subfields(field, &block)
-      field.select { |v| block.call(v) }.map(&:value).select { |v| v.present? }.join(' ')
-    end
-
-    # this is used for filtering in a lots of places
-    # returns a lambda that can be passed to Enumerable#select
-    # using the & syntax
-    def subfield_not_6_or_8
-      @subfield_not_6_or_8 ||= lambda { |subfield|
-        !%w{6 8}.member?(subfield.code)
-      }
-    end
-
-    # returns a lambda checking if passed-in subfield's code
-    # is a member of array
-    def subfield_in(array)
-      lambda { |subfield| array.member?(subfield.code) }
-    end
-
-    # returns a lambda checking if passed-in subfield's code
-    # is NOT a member of array
-    def subfield_not_in(array)
-      lambda { |subfield| !array.member?(subfield.code) }
-    end
-
-
-    # 11/2018 kms: eventually should deprecate has_subfield6_value and use this for all
-    # returns true if field has a value that matches
-    # passed-in regex and passed in subfield
-    def has_subfield_value(field, subf, regex)
-      field.any? { |sf| sf.code == subf && sf.value =~ regex }
-    end
-
-    def subfield_value_in(field, subf, array)
-      field.any? { |sf| sf.code == subf && sf.value.in?(array) }
-    end
-
-    # common case of wanting to extract subfields as selected by passed-in block,
-    # from 880 datafield that has a particular subfield 6 value
-    # @param subf6_value [String|Array] either a single str value to look for in sub6 or an array of them
-    # @param block [Proc] takes a subfield as argument, returns a boolean
-    def get_880(rec, subf6_value, &block)
-      regex_value = subf6_value
-      if subf6_value.is_a?(Array)
-        regex_value = "(#{subf6_value.join('|')})"
-      end
-
-      rec.fields('880')
-         .select { |f| has_subfield6_value(f, /^#{regex_value}/) }
-         .map do |field|
-        field.select { |sf| block.call(sf) }.map(&:value).join(' ')
-      end
-    end
-
-    # common case of wanting to extract all the subfields besides 6 or 8,
-    # from 880 datafield that has a particular subfield 6 value
-    def get_880_subfield_not_6_or_8(rec, subf6_value)
-      get_880(rec, subf6_value) do |sf|
-        !%w{6 8}.member?(sf.code)
-      end
-    end
-
-    # returns the non-6,8 subfields from a datafield and its 880 link
-    def get_datafield_and_880(rec, tag)
-      acc = []
-      acc += rec.fields(tag).map do |field|
-        join_subfields(field, &subfield_not_in(%w{6 8}))
-      end
-      acc += get_880_subfield_not_6_or_8(rec, tag)
-      acc
-    end
-
-    def append_title_variant_field(acc, non_filing, subfields)
-      base = subfields.shift;
-      return if base.nil? # there's something wrong; first is always required
-      if non_filing =~ /[1-9]/
-        prefix = base.slice!(0, non_filing.to_i)
-      end
-      loop do
-        acc << base
-        if !prefix.nil?
-          acc << prefix + base
-        end
-        return if subfields.empty?
-        while (next_part = subfields.shift).nil?
-          return if subfields.empty?
-        end
-        base = "#{base} #{next_part}"
-      end
-    end
-
-    # returns true if field's subfield 6 has a value that matches
-    # passed-in regex
-    def has_subfield6_value(field, regex)
-      field.any? { |sf| sf.code == '6' && sf.value =~ regex }
-    end
-
-    # for a string 's', return a hash of ref_type => Array of references,
-    # where a reference is a String or a Hash representing a multipart string
-    def get_subject_references(s)
-      # TODO: just simple test data for now; hook up to actual cross ref data
-      case s
-      when 'Cyberspace'
-        { 'see_also' => [ 'Internet', 'Computer networks' ] }
-      when 'Internet'
-        { 'see_also' => [ 'Cyberspace', 'Computer networks' ] }
-      when 'Computer networks'
-        { 'see_also' => [ 'Cyberspace', 'Internet' ] }
-        # one way
-      when 'Programming Languages'
-        { 'use_instead' => [ 'Computer programming' ] }
-      end
-    end
-
-    def subject_codes
-      @subject_codes ||= %w(600 610 611 630 650 651)
-    end
-
-    def subject_codes_to_xfacet_prefixes
-      @subject_codes_to_xfacet_prefixes ||= {
-        600 => 'n',
-        610 => 'n',
-        611 => 'n',
-        630 => 't',
-        650 => 's',
-        651 => 'g'
-      }
-    end
-
-    def is_subject_field(field)
-      # 10/2018 kms: add 2nd Ind 7
-      subject_codes.member?(field.tag) && (%w(0 2 4).member?(field.indicator2) ||
-        (field.indicator2 == '7' && field.any? do |sf|
-          sf.code == '2' && ALLOWED_SUBJ_GENRE_ONTOLOGIES.member?(sf.value)
-        end))
-    end
-
-    def reject_pro_chr(sf)
-      %w{a %}.member?(sf.code) && sf.value =~ /^%?(PRO|CHR)([ $]|$)/
-    end
-
-    def is_curated_database(rec)
-      rec.fields('944').any? do |field|
-        field.any? do |sf|
-          sf.code == 'a' && sf.value == 'Database & Article Index'
-        end
-      end
-    end
-
-    def get_curated_format(rec)
-      rec.fields('944').map do |field|
-        sf = field.find { |sf| sf.code == 'a' }
-        sf.nil? || (sf.value == sf.value.to_i.to_s) ? nil : sf.value
-      end.compact.uniq
-    end
-
-    def get_db_types(rec)
-      return [] unless is_curated_database(rec)
-      rec.fields('944').map do |field|
-        if field.any? { |sf| sf.code == 'a' && sf.value == PennLib::Marc::DATABASES_FACET_VALUE }
-          sf = field.find { |sf| sf.code == 'b' }
-          sf.nil? ? nil : sf.value
-        end
-      end.compact
-    end
-
-    def get_db_categories(rec)
-      return [] unless is_curated_database(rec)
-      rec.fields('943').map do |field|
-        if field.any? { |sf| sf.code == '2' && sf.value == 'penncoi' }
-          sf = field.find { |sf| sf.code == 'a' }
-          sf.nil? ? nil : sf.value
-        end
-      end.compact
-    end
-
-    def get_db_subcategories(rec)
-      return [] unless is_curated_database(rec)
-      rec.fields('943').map do |field|
-        if field.any? { |sf| sf.code == '2' && sf.value == 'penncoi' }
-          category = field.find { |sf| sf.code == 'a' }
-          unless category.nil?
-            sub_category = field.find { |sf| sf.code == 'b' }
-            sub_category.nil? ? category : "#{category.value}--#{sub_category.value}"
-          end
-        end
-      end.compact
-    end
-
-    # TODO: MG removed the join_subject_parts method when adding in the SubjectConfig module here. This method still
-    # appears to be in use in the FranklinIndexer even though many subject fields are now processed differently
-    # Work should be done to remove all usages of join_subject_parts. Perhaps functionality from SubjectConfig could
-    # be used instead
-    def get_subject_facet_values(rec, toplevel_only = false)
-      rec.fields.find_all { |f| is_subject_field(f) }.map do |field|
-        just_a = nil
-        if field.any? { |sf| sf.code == 'a' } && (toplevel_only || field.any? { |sf| sf.code != 'a' })
-          just_a = field.find_all(&subfield_in(%w{a})).map(&:value)
-                        .select { |v| v !~ /^%?(PRO|CHR)/ }.join(' ')
-        end
-        [ (toplevel_only ? nil : join_subject_parts(field)), just_a ].compact.map{ |v| trim_trailing_period(v) }
-      end.flatten(1).select { |v| v.present? }
-    end
-
-    def get_subject_xfacet_values(rec)
-      rec.fields.find_all { |f| is_subject_field(f) }
-         .map { |f| { field: f, prefix: subject_codes_to_xfacet_prefixes[f.tag.to_i] } }
-         .map { |f_struct| f_struct[:value] = trim_trailing_period(join_subject_parts(f_struct[:field], double_dash: true)); f_struct }
-         .select { |f_struct| f_struct[:value].present? }
-         .map { |f_struct| f_struct[:prefix] + f_struct[:value] }
-      # don't need to wrap data in #references anymore because cross refs are now handled Solr-side
-      #   .map { |s| references(s, refs: get_subject_references(s)) }
-    end
-
-    def subject_search_tags
-      @subject_search_tags ||= %w{541 561 600 610 611 630 650 651 653}
-    end
-
-    def is_subject_search_field(field)
-      # 11/2018 kms: add 2nd Ind 7
-      if ! (field.respond_to?(:indicator2) && %w{0 1 2 4 7}.member?(field.indicator2))
-        false
-      elsif subject_search_tags.member?(field.tag) || field.tag.start_with?('69')
-        true
-      elsif field.tag == '880'
-        sub6 = (field.find_all { |sf| sf.code == '6' }.map(&:value).first || '')[0..2]
-        subject_search_tags.member?(sub6) || sub6.start_with?('69')
-      else
-        false
-      end
-    end
-
-    def get_subject_search_values(rec)
-      # this has been completely migrated
-      rec.fields.find_all { |f| is_subject_search_field(f) }
-         .map do |field|
-        subj = []
-        field.each do |sf|
-          if sf.code == 'a'
-            subj << " #{sf.value.gsub(/^%?(PRO|CHR)/, '').gsub(/\?$/, '')}"
-          elsif sf.code == '4'
-            subj << "#{sf.value}, #{relator_codes[sf.value]}"
-          elsif !%w{a 4 5 6 8}.member?(sf.code)
-            subj << " #{sf.value}"
-          end
-        end
-        join_and_trim_whitespace(subj) if subj.present?
-      end.compact
-    end
-
-    # @returns [Array] of string field tags to examine for subjects
-    def subject_600s
-      @subject_600s ||= %w{600 610 611 630 650 651}
-    end
-
-    # 11/2018 kms: add local subj fields- always Local no matter the 2nd Ind
-    def subject_69X
-      @subject_69X ||= %w{690 691 697}
-    end
-
-    # 11/2018: add 69x as local subj, add 650 _7 as subj
-    def get_subjects_from_600s_and_800(rec, indicator2)
-      track_dups = Set.new
-      acc = []
-      if %w{0 1 2}.member?(indicator2)
-        #Subjects, Childrens subjects, and Medical Subjects all share this code
-        # also 650 _7, subjs w/ source specified in $2. These display as Subjects along w/ the ind2==0 650s
-        acc += rec.fields
-                  .select { |f| subject_600s.member?(f.tag) ||
-                    (f.tag == '880' && has_subfield6_value(f, /^(#{subject_600s.join('|')})/)) }
-                  .select { |f| f.indicator2 == indicator2 || (f.indicator2 == '7' && indicator2 == '0' && f.any? do |sf|
-                    sf.code == '2' && ALLOWED_SUBJ_GENRE_ONTOLOGIES.member?(sf.value)
-                  end)}
-                  .map do |field|
-          #added 2017/04/10: filter out 0 (authority record numbers) added by Alma
-          value_for_link = join_subfields(field, &subfield_not_in(%w{0 6 8 2 e w}))
-          sub_with_hyphens = field.select(&subfield_not_in(%w{0 6 8 2 e w})).map do |sf|
-            pre = !%w{a b c d p q t}.member?(sf.code) ? ' -- ' : ' '
-            pre + sf.value + (sf.code == 'p' ? '.' : '')
-          end.join(' ')
-          eandw_with_hyphens = field.select(&subfield_in(%w{e w})).map do |sf|
-            ' -- ' + sf.value
-          end.join(' ')
-          if sub_with_hyphens.present?
-            {
-              value: sub_with_hyphens,
-              value_for_link: value_for_link,
-              value_append: eandw_with_hyphens,
-              link_type: 'subject_xfacet2'
-            }
-          end
-        end.compact.select { |val| track_dups.add?(val) }
-      elsif indicator2 == '4'
-        # Local subjects
-        # either a tag in subject_600s list with ind2==4, or a tag in subject_69X list with any ind2.
-        # but NOT a penn community of interest 690 (which have $2 penncoi )
-        acc += rec.fields
-                  .select { |f| subject_600s.member?(f.tag) && f.indicator2 == '4' ||
-                    ( subject_69X.member?(f.tag)  && !(has_subfield_value(f,'2',/penncoi/))  ) }
-                  .map do |field|
-          suba = field.select(&subfield_in(%w{a}))
-                      .select { |sf| sf.value !~ /^%?(PRO|CHR)/ }
-                      .map(&:value).join(' ')
-          #added 2017/04/10: filter out 0 (authority record numbers) added by Alma
-          # 11/2018 kms: also do not display subf 5 or 2
-          sub_oth = field.select(&subfield_not_in(%w{0 a 6 8 5 2})).map do |sf|
-            pre = !%w{b c d p q t}.member?(sf.code) ? ' -- ' : ' '
-            pre + sf.value + (sf.code == 'p' ? '.' : '')
-          end
-          subj_display = [ suba, sub_oth ].join(' ')
-          #added 2017/04/10: filter out 0 (authority record numbers) added by Alma
-          # 11/2018 kms: also do not display subf 5 or 2
-          sub_oth_no_hyphens = join_subfields(field, &subfield_not_in(%w{0 a 6 8 5 2}))
-          subj_search = [ suba, sub_oth_no_hyphens ].join(' ')
-          if subj_display.present?
-            {
-              value: subj_display,
-              value_for_link: subj_search,
-              link_type: 'subject_search'
-            }
-          end
-        end.compact.select { |val| track_dups.add?(val) }
-      end
-      acc
-    end
-
-    # 11/2018: 650 _7 is also handled here
-    def get_subject_display(rec)
-      get_subjects_from_600s_and_800(rec, '0')
-    end
-
-    def get_children_subject_display(rec)
-      get_subjects_from_600s_and_800(rec, '1')
-    end
-
-    def get_medical_subject_display(rec)
-      get_subjects_from_600s_and_800(rec, '2')
-    end
-
-    def get_local_subject_display(rec)
-      get_subjects_from_600s_and_800(rec, '4')
-    end
-
-    def get_subject_solrdoc_display(doc)
-      doc[:default_subject_stored_a]
-    end
-
-    def get_children_subject_solrdoc_display(doc)
-      doc[:childrens_subject_stored_a]
-    end
-
-    def get_medical_subject_solrdoc_display(doc)
-      doc[:mesh_subject_stored_a]
-    end
-
-    def get_local_subject_solrdoc_display(doc)
-      doc[:local_subject_stored_a]
-    end
-
-    def get_format(rec)
-      acc = []
-
-      format_code = get_format_from_leader(rec)
-      f008 = rec.fields('008').map(&:value).first || ''
-      f007 = rec.fields('007').map(&:value)
-      f260press = rec.fields('260').any? do |field|
-        field.select { |sf| sf.code == 'b' && sf.value =~ /press/i }.any?
-      end
-      # first letter of every 006
-      f006firsts = rec.fields('006').map do |field|
-        field.value[0]
-      end
-      f245k = rec.fields('245').flat_map do |field|
-        field.select { |sf| sf.code == 'k' }.map(&:value)
-      end
-      f245h = rec.fields('245').flat_map do |field|
-        field.select { |sf| sf.code == 'h' }.map(&:value)
-      end
-      f337a = rec.fields('337').flat_map do |field|
-        field.select { |sf| sf.code == 'a' }.map(&:value)
-      end
-      call_nums = rec.fields(EnrichedMarc::TAG_HOLDING).map do |field|
-        # h gives us the 'Classification part' which contains strings like 'Microfilm'
-        join_subfields(field, &subfield_in([ EnrichedMarc::SUB_HOLDING_CLASSIFICATION_PART, EnrichedMarc::SUB_HOLDING_ITEM_PART ]))
-      end
-      locations = get_specific_location_values(rec)
-
-      if locations.any? { |loc| loc =~ /manuscripts/i }
-        acc << 'Manuscript'
-      elsif locations.any? { |loc| loc =~ /archives/i } &&
-        locations.none? { |loc| loc =~ /cajs/i } &&
-        locations.none? { |loc| loc =~ /nursing/i }
-        acc << 'Archive'
-      elsif locations.any? { |loc| loc =~ /micro/i } ||
-        f245h.any? { |val| val =~ /micro/i } ||
-        call_nums.any? { |val| val =~ /micro/i } ||
-        f337a.any? { |val| val =~ /microform/i }
-        acc << 'Microformat'
-      else
-        # these next 4 can have this format plus ONE of the formats down farther below
-        if rec.fields('502').any? && format_code == 'tm'
-          acc << 'Thesis/Dissertation'
-        end
-        if rec.fields('111').any? || rec.fields('711').any?
-          acc << 'Conference/Event'
-        end
-        if (!%w{c d i j}.member?(format_code[0])) && %w{f i o}.member?(f008[28]) && (!f260press)
-          acc << 'Government document'
-        end
-        if format_code == 'as' && (f008[21] == 'n' || f008[22] == 'e')
-          acc << 'Newspaper'
-        end
-
-        # only one of these
-        if format_code.end_with?('i') || (format_code == 'am' && f006firsts.member?('m') && f006firsts.member?('s'))
-          acc << 'Website/Database'
-        elsif %w(aa ac am tm).member?(format_code) &&
-          f245k.none? { |v| v =~ /kit/i } &&
-          f245h.none? { |v| v =~ /micro/i }
-          acc << 'Book'
-        elsif %w(ca cb cd cm cs dm).member?(format_code)
-          acc << 'Musical score'
-        elsif format_code.start_with?('e') || format_code == 'fm'
-          acc << 'Map/Atlas'
-        elsif format_code == 'gm'
-          if f007.any? { |v| v.start_with?('v') }
-            acc << 'Video'
-          elsif f007.any? { |v| v.start_with?('g') }
-            acc << 'Projected graphic'
-          else
-            acc << 'Video'
-          end
-        elsif %w(im jm jc jd js).member?(format_code)
-          acc << 'Sound recording'
-        elsif %w(km kd).member?(format_code)
-          acc << 'Image'
-        elsif format_code == 'mm'
-          acc << 'Datafile'
-        elsif %w(as gs).member?(format_code)
-          acc << 'Journal/Periodical'
-        elsif format_code.start_with?('r')
-          acc << '3D object'
-        else
-          acc << 'Other'
-        end
-      end
-      acc.concat(get_curated_format(rec))
-    end
-
-    # returns two-char format code from MARC leader, representing two fields:
-    # "Type of record" and "Bibliographic level"
-    def get_format_from_leader(rec)
-      rec.leader[6..7]
-    end
-
-    def get_format_display(rec)
-      results = []
-      results += rec.fields('300').map do |field|
-        join_subfields(field, &subfield_not_in(%w{3 6 8}))
-      end
-      results += rec.fields(%w{254 255 310 342 352 362}).map do |field|
-        join_subfields(field, &subfield_not_in(%w{6 8}))
-      end
-      results += rec.fields('340').map do |field|
-        join_subfields(field, &subfield_not_in(%w{0 2 6 8}))
-      end
-      results += rec.fields('880').map do |field|
-        if has_subfield6_value(field,/^300/)
-          join_subfields(field, &subfield_not_in(%w{3 6 8}))
-        elsif has_subfield6_value(field, /^(254|255|310|342|352|362)/)
-          join_subfields(field, &subfield_not_in(%w{6 8}))
-        elsif has_subfield6_value(field, /^340/)
-          join_subfields(field, &subfield_not_in(%w{0 2 6 8}))
-        else
-          []
-        end
-      end
-      results.select { |value| value.present? }
-    end
-
-    def get_itm_count(rec)
-      fields = rec.fields(EnrichedMarc::TAG_ITEM)
-      fields.empty? ? nil : fields.size
-    end
-
-    def get_hld_count(rec)
-      fields = rec.fields(EnrichedMarc::TAG_HOLDING)
-      fields.empty? ? nil : fields.size
-    end
-
-    def get_empty_hld_count(rec)
-      holding_ids_from_items = Set.new
-      rec.each_by_tag(EnrichedMarc::TAG_ITEM) do |field|
-        holding_id_subfield = field.find do |subfield|
-          subfield.code == 'r'
-        end
-        holding_ids_from_items.add(holding_id_subfield.value) if holding_id_subfield
-      end
-      empty_holding_count = 0
-      rec.each_by_tag(EnrichedMarc::TAG_HOLDING) do |field|
-        id_subfield = field.find do |subfield|
-          subfield.code == '8'
-        end
-        unless holding_ids_from_items.include?(id_subfield&.value)
-          empty_holding_count += 1
-        end
-      end
-      empty_holding_count
-    end
-
-    def get_prt_count(rec)
-      fields = rec.fields(EnrichedMarc::TAG_ELECTRONIC_INVENTORY)
-      fields.empty? ? nil : fields.size
-    end
-
-    def get_access_values(rec)
-      acc = rec.map do |f|
-        case f.tag
-        when EnrichedMarc::TAG_HOLDING
-          'At the library'
-        when EnrichedMarc::TAG_ELECTRONIC_INVENTORY
-          'Online'
-        end
-      end.compact
-      acc += rec.fields('856')
-                .select { |f| f.indicator1 == '4' && f.indicator2 != '2' }
-                .flat_map do |field|
-        subz = join_subfields(field, &subfield_in(%w{z}))
-        field.find_all(&subfield_in(%w{u})).map do |sf|
-          if !subz.include?('Finding aid') && sf.value.include?('hdl.library.upenn.edu')
-            'Online'
-          end
-        end.compact
-      end
-      acc << 'Online' if is_etas(rec)
-      acc.uniq
-    end
-
-    def is_etas(rec)
-      rec.fields('977').any? do |f|
-        f.any? do |sf|
-          sf.code == 'e' && sf.value == 'ETAS'
-        end
-      end
-    end
-
-    # examines a 1xx datafield and constructs a string out of select
-    # subfields, including expansion of 'relator' code
-    def get_name_1xx_field(field)
-      s = field.map do |sf|
-        # added 2017/04/10: filter out 0 (authority record numbers) added by Alma
-        # added 2022/08/04: filter our 1 (URIs) added my MARCive project
-        if !%W{0 1 4 6 8}.member?(sf.code)
-          " #{sf.value}"
-        elsif sf.code == '4'
-          ", #{relator_codes[sf.value]}"
-        end
-      end.compact.join
-      s2 = s + (!%w(. -).member?(s[-1]) ? '.' : '')
-      normalize_space(s2)
-    end
-
-    def get_series_8xx_field(field)
-      s = field.map do |sf|
-        # added 2017/04/10: filter out 0 (authority record numbers) added by Alma
-        if(! %W{0 4 5 6 8}.member?(sf.code))
-          " #{sf.value}"
-        elsif sf.code == '4'
-          ", #{relator_codes[sf.value]}"
-        end
-      end.compact.join
-      s2 = s + (!%w(. -).member?(s[-1]) ? '.' : '')
-      normalize_space(s2)
-    end
-
-    def get_series_4xx_field(field)
-      s = field.map do |sf|
-        # added 2017/04/10: filter out 0 (authority record numbers) added by Alma
-        if(! %W{0 4 6 8}.member?(sf.code))
-          " #{sf.value}"
-        elsif sf.code == '4'
-          ", #{relator_codes[sf.value]}"
-        end
-      end.compact.join
-      s2 = s + (!%w(. -).member?(s[-1]) ? '.' : '')
-      normalize_space(s2)
-    end
-
-    def get_publication_values(rec)
-      acc = []
-      rec.fields('245').each do |field|
-        field.find_all { |sf| sf.code == 'f' }
-             .map(&:value)
-             .each { |value| acc << value }
-      end
-      added_2xx = false
-      rec.fields(%w{260 261 262}).take(1).each do |field|
-        results = field.find_all { |sf| sf.code != '6' }
-                       .map(&:value)
-        acc << join_and_trim_whitespace(results)
-        added_2xx = true
-      end
-      if(!added_2xx)
-        sf_ab264 = rec.fields.select { |field| field.tag == '264' && field.indicator2 == '1' }
-                      .take(1)
-                      .flat_map do |field|
-          field.find_all(&subfield_in(%w{a b})).map(&:value)
-        end
-
-        sf_c264_1 = rec.fields.select { |field| field.tag == '264' && field.indicator2 == '1' }
-                       .take(1)
-                       .flat_map do |field|
-          field.find_all(&subfield_in(['c']))
-               .map(&:value)
-        end
-
-        sf_c264_4 = rec.fields.select { |field| field.tag == '264' && field.indicator2 == '4' }
-                       .take(1)
-                       .flat_map do |field|
-          field.find_all { |sf| sf.code == 'c' }
-               .map { |sf| (sf_c264_1.present? ? ', ' : '') + sf.value }
-        end
-
-        acc << [sf_ab264, sf_c264_1, sf_c264_4].join(' ')
-      end
-      acc.map!(&:strip).select!(&:present?)
-      acc
-    end
-
-    def get_publication_display(rec)
-      acc = []
-      rec.fields('245').take(1).each do |field|
-        field.find_all { |sf| sf.code == 'f' }
-             .map(&:value)
-             .each { |value| acc << value }
-      end
-      rec.fields(%w{260 261 262}).take(1).each do |field|
-        acc << join_subfields(field, &subfield_not_6_or_8)
-      end
-      rec.fields('880')
-         .select { |f| has_subfield6_value(f, /^(260|261|262)/) }
-         .take(1)
-         .each do |field|
-        acc << join_subfields(field, &subfield_not_6_or_8)
-      end
-      rec.fields('880')
-         .select { |f| has_subfield6_value(f, /^245/) }
-         .each do |field|
-        acc << join_subfields(field, &subfield_in(['f']))
-      end
-      acc += get_264_or_880_fields(rec, '1')
-      acc.select(&:present?)
-    end
-
-    def get_language_values(rec)
-      rec.fields('008').map do |field|
-        lang_code = field.value[35..37]
-        if lang_code
-          languages[lang_code]
-        end
-      end.compact
-    end
-
-    # fieldname = name of field in the locations data structure to use
-    def holdings_location_mappings(rec, display_fieldname)
-
-      # in holdings records, the shelving location is always the permanent location.
-      # in item records, the current location takes into account
-      # temporary locations and permanent locations. if you update the item's perm location,
-      # the holding's shelving location changes.
-      #
-      # Since item records may reflect locations more accurately, we use them if they exist;
-      # if not, we use the holdings.
-
-      tag = EnrichedMarc::TAG_HOLDING
-      subfield_code = EnrichedMarc::SUB_HOLDING_SHELVING_LOCATION
-
-      if rec.fields(EnrichedMarc::TAG_ITEM).size > 0
-        tag = EnrichedMarc::TAG_ITEM
-        subfield_code = EnrichedMarc::SUB_ITEM_CURRENT_LOCATION
-      end
-
-      # we don't facet for 'web' which is the 'Penn Library Web' location used in Voyager.
-      # this location should eventually go away completely with data cleanup in Alma.
-
-      acc = rec.fields(tag).flat_map do |field|
-        results = field.find_all { |sf| sf.code == subfield_code }
-                       .select { |sf| sf.value != 'web' }
-                       .map { |sf|
-                         # sometimes "happening locations" are mistakenly
-                         # used in holdings records. that's a data problem that should be fixed.
-                         # here, if we encounter a code we can't map, we ignore it, for faceting purposes.
-                         if locations[sf.value].present?
-                           locations[sf.value][display_fieldname]
-                         end
-                       }
-        # flatten multiple 'library' values
-        results.select(&:present?).flatten
-      end.uniq
-      if rec.fields(EnrichedMarc::TAG_ELECTRONIC_INVENTORY).any?
-        acc << 'Online library'
-      end
-      return acc
-    end
-
-    def items_nocirc(rec)
-      items = rec.fields(EnrichedMarc::TAG_ITEM)
-      return 'na' if items.empty?
-      all = true
-      none = true
-      items.each do |f|
-        nocirc = f.any? do |sf|
-          sf.code == EnrichedMarc::SUB_ITEM_CURRENT_LOCATION && sf.value == 'vanpNocirc'
-        end
-        if nocirc
-          none = false
-        else
-          all = false
-        end
-      end
-      if all
-        return 'all'
-      elsif none
-        return 'none'
-      else
-        return 'partial'
-      end
-    end
-
-    def get_library_values(rec)
-      holdings_location_mappings(rec, 'library')
-    end
-
-    def get_specific_location_values(rec)
-      holdings_location_mappings(rec, 'specific_location')
-    end
-
-    def get_encoding_level_rank(rec)
-      EncodingLevel::RANK[rec.leader[17]]
-    end
-
-    def prepare_dates(rec)
-      f008 = rec.fields('008').first
-      return nil unless f008
-      field = f008.value
-      return nil unless date_type = field[6]
-      return nil unless date1 = field[7,4]
-      date2 = field[11,4]
-      case DateType::MAP[date_type]
-      when :single
-        return build_dates_hash(date1)
-      when :lower_bound
-        return build_dates_hash(date1, '9999')
-      when :range
-        return build_dates_hash(date1, date2)
-      when :separate_content
-        return build_dates_hash(date1, nil, date2)
-      else
-        return nil
-      end
-    end
-
-    def build_dates_hash(raw_pub_date_start, raw_pub_date_end = nil, content_date = nil)
-      pub_date_start = sanitize_date(raw_pub_date_start, '0')
-      return nil if pub_date_start == nil
-      if raw_pub_date_end && pub_date_end = sanitize_date(raw_pub_date_end, '9')
-        if pub_date_start > pub_date_end
-          # assume date type coded incorrectly; use date2 as content_date
-          pub_date_end = sanitize_date(raw_pub_date_start, '9')
-          content_date = raw_pub_date_end
-        end
-      else
-        pub_date_end = sanitize_date(raw_pub_date_start, '9')
-      end
-      if content_date == nil
-        content_date_start = pub_date_start
-        content_date_end = pub_date_end
-      elsif content_date =~ /^[0-9]{4}$/
-        content_date_start = content_date_end = content_date
-      else
-        content_date_start = sanitize_date(content_date, '0')
-        if content_date_start
-          content_date_end = sanitize_date(content_date, '9')
-        else
-          # invalid separate content date provided; fall back to pub_date
-          content_date_start = pub_date_start
-          content_date_end = pub_date_end
-        end
-      end
-      {
-        :pub_date_sort => pub_date_start,
-        :pub_date_decade => current_year + 15 > pub_date_start.to_i ? pub_date_start[0,3] + '0s' : nil,
-        :pub_date_range => "[#{pub_date_start} TO #{pub_date_end}]",
-        :content_date_range => "[#{content_date_start} TO #{content_date_end}]",
-        :pub_date_minsort => "#{pub_date_start}-01-01T00:00:00Z",
-        :pub_date_maxsort => "#{pub_date_end.to_i + 1}-01-01T00:00:00Z",
-        :content_date_minsort => "#{content_date_start}-01-01T00:00:00Z",
-        :content_date_maxsort => "#{content_date_end.to_i + 1}-01-01T00:00:00Z"
-      }
-    end
-
-    def sanitize_date(input, replace)
-      return nil if input !~ /^[0-9]*u*$/
-      input.gsub(/u/, replace)
-    end
-
-    def publication_date_digits(rec)
-      rec.fields('008').map { |field| field.value[7,4] }
-         .select { |year| year.present? }
-         .map { |year| year.gsub(/\D/, '0') }
-    end
-
-    def get_publication_date_values(rec)
-      publication_date_digits(rec)
-        .select { |year| year =~ /^[1-9][0-9]/ && current_year + 15 > year.to_i }
-        .map { |year| year[0, 3] + '0s' }
-    end
-
-    def get_publication_date_sort_values(rec)
-      publication_date_digits(rec)
-    end
-
-    def get_classification_values(rec)
-      acc = []
-      # not sure whether it's better to use 'item' or 'holding' records here.
-      # we use 'item' only because it has a helpful call number type subfield,
-      # which the holding doesn't.
-      rec.fields(EnrichedMarc::TAG_ITEM).each do |item|
-        cn_type = item.find_all { |sf| sf.code == EnrichedMarc::SUB_ITEM_CALL_NUMBER_TYPE }.map(&:value).first
-
-        results = item.find_all { |sf| sf.code == EnrichedMarc::SUB_ITEM_CALL_NUMBER }
-                      .map(&:value)
-                      .select { |call_num| call_num.present? }
-                      .map { |call_num| call_num[0] }
-                      .compact
-
-        results.each do |letter|
-          verbose = nil
-          case cn_type
-          when '0'
-            verbose = loc_classifications[letter]
-          when '1'
-            verbose = dewey_classifications[letter]
-            letter = letter + '00'
-          end
-          if verbose
-            acc << [ letter, verbose ].join(' - ')
-          end
-        end
-      end
-      acc.uniq
-    end
-
-    def get_genre_values(rec)
-      acc = []
-
-      is_manuscript = rec.fields(EnrichedMarc::TAG_ITEM).any? do |item|
-        loc = item[EnrichedMarc::SUB_ITEM_CURRENT_LOCATION]
-        locations[loc].present? && (locations[loc]['specific_location'] =~ /manuscript/)
-      end
-
-      if rec['007'].try { |r| r.value.start_with?('v') } || is_manuscript
-        genres = rec.fields('655').map do |field|
-          field.find_all(&subfield_not_in(%w{0 2 5 c}))
-               .map(&:value)
-               .join(' ')
-        end
-        genres.each { |genre| acc << genre }
-      end
-      acc
-    end
-
-    def get_genre_search_values(rec)
-      rec.fields('655').map do |field|
-        join_subfields(field, &subfield_not_in(%w{0 2 5 c}))
-      end
-    end
-
-    # @param [MARC::Record] rec
-    # @param [TrueClass, FalseClass] should_link
-    def get_genre_display(rec, should_link)
-      rec.fields
-         .select { |field|
-           GenreTools.allowed_genre_field? field
-         }.map do |field|
-        sub_with_hyphens = field.find_all(&subfield_not_in(%w{0 2 5 6 8 c e w})).map { |sf|
-          sep = !%w{a b}.member?(sf.code) ? ' -- ' : ' '
-          sep + sf.value
-        }.join.lstrip
-        eandw_with_hyphens = field.find_all(&subfield_in(%w{e w})).join(' -- ')
-        { value: sub_with_hyphens, value_append: eandw_with_hyphens, link: should_link, link_type: 'genre_search' }
-      end.uniq
-    end
-
-    def get_title_values(rec)
-      acc = []
-      rec.fields('245').take(1).each do |field|
-        a_or_k = field.find_all(&subfield_in(%w{a k}))
-                      .map { |sf| trim_trailing_comma(trim_trailing_slash(sf.value).rstrip) }
-                      .first || ''
-        joined = field.find_all(&subfield_in(%w{b n p}))
-                      .map{ |sf| trim_trailing_slash(sf.value) }
-                      .join(' ')
-
-        apunct = a_or_k[-1]
-        hpunct = field.find_all { |sf| sf.code == 'h' }
-                      .map{ |sf| sf.value[-1] }
-                      .first
-        punct = if [apunct, hpunct].member?('=')
-                  '='
-                else
-                  [apunct, hpunct].member?(':') ? ':' : nil
-                end
-
-        acc << [ trim_trailing_colon(trim_trailing_equal(a_or_k)), punct, joined ]
-                 .select(&:present?).join(' ')
-      end
-      acc
-    end
-
-    def get_title_880_values(rec)
-      rec.fields('880')
-         .select { |f| has_subfield6_value(f, /^245/) }
-         .map do |field|
-        suba_value = field.find_all(&subfield_in(%w{a})).first.try(:value)
-        subk_value = field.find_all(&subfield_in(%w{k})).first.try(:value) || ''
-        title_with_slash = suba_value.present? ? suba_value : (subk_value + ' ')
-        title_ak = trim_trailing_comma(join_and_trim_whitespace([ trim_trailing_slash(title_with_slash) ]))
-
-        subh = join_and_trim_whitespace(field.find_all(&subfield_in(%w{h})).map(&:value))
-
-        apunct = title_ak[-1]
-        hpunct = subh[-1]
-
-        punct = if [apunct, hpunct].member?('=')
-                  '='
-                else
-                  [apunct, hpunct].member?(':') ? ':' : nil
-                end
-
-        [ trim_trailing_equal(title_ak),
-          punct,
-          trim_trailing_slash(field.find_all(&subfield_in(%w{b})).first.try(:value) || ''),
-          trim_trailing_slash(field.find_all(&subfield_in(%w{n})).first.try(:value) || ''),
-          trim_trailing_slash(field.find_all(&subfield_in(%w{p})).first.try(:value) || '')
-        ]
-          .select { |value| value.present? }
-          .join(' ')
-      end
-    end
-
-    def separate_leading_bracket_into_prefix_and_filing_hash(s)
-      if s.start_with?('[')
-        { 'prefix' => '[', 'filing' => s[1..-1] }
-      else
-        { 'prefix' => '', 'filing' => s }
-      end
-    end
-
-    def get_title_from_245_or_880(fields, support_invalid_indicator2 = true)
-      fields.map do |field|
-        if field.indicator2 =~ /^[0-9]$/
-          offset = field.indicator2.to_i
-        elsif support_invalid_indicator2
-          offset = 0 # default to 0
-        else
-          return []
-        end
-        value = {}
-        suba = join_subfields(field, &subfield_in(%w{a}))
-        if offset > 0 && offset < 10
-          part1 = suba[0..offset-1]
-          part2 = suba[offset..-1]
-          value = { 'prefix' => part1, 'filing' => part2 }
-        else
-          if suba.present?
-            value = separate_leading_bracket_into_prefix_and_filing_hash(suba)
-          else
-            subk = join_subfields(field, &subfield_in(%w{k}))
-            value = separate_leading_bracket_into_prefix_and_filing_hash(subk)
-          end
-        end
-        value['filing'] = [ value['filing'], join_subfields(field, &subfield_in(%w{b n p})) ].join(' ')
-        value
-      end.compact
-    end
-
-    def get_title_245(rec, support_invalid_indicator2 = true)
-      get_title_from_245_or_880(rec.fields('245').take(1), support_invalid_indicator2)
-    end
-
-    def get_title_880_for_xfacet(rec)
-      get_title_from_245_or_880(rec.fields('880').select { |f| has_subfield6_value(f, /^245/) })
-    end
-
-    def get_title_xfacet_values(rec)
-      # 6/16/2017: added 880 to this field for non-roman char handling
-      get_title_245(rec).map do |v|
-        references(v)
-      end + get_title_880_for_xfacet(rec).map do |v|
-        references(v)
-      end
-    end
-
-    def get_title_sort_values(rec)
-      get_title_245(rec).map do |v|
-        v['filing'] + v['prefix']
-      end
-    end
-
-    def get_title_sort_filing_parts(rec, support_invalid_indicator2 = true)
-      get_title_245(rec, support_invalid_indicator2).map do |v|
-        v['filing']
-      end
-    end
-
-    def append_title_variants(rec, acc)
-      do_title_variant_field(rec, acc, '130', 1, 'a')
-      do_title_variant_field(rec, acc, '240', 2, 'a')
-      do_title_variant_field(rec, acc, '210', nil, 'a', 'b')
-      do_title_variant_field(rec, acc, '222', 2, 'a', 'b')
-      do_title_variant_field(rec, acc, '246', nil, 'a', 'b')
-    end
-
-    def do_title_variant_field(rec, acc, field_id, non_filing_indicator, *subfields_spec)
-      rec.fields(field_id).each do |field|
-        parts = subfields_spec.map do |subfield_spec|
-          matching_subfield = field.find { |subfield| subfield.code == subfield_spec }
-          matching_subfield.value unless matching_subfield.nil?
-        end
-        next if parts.first.nil?
-        parts.compact!
-        case non_filing_indicator
-        when 1
-          non_filing = field.indicator1
-        when 2
-          non_filing = field.indicator2
-        else
-          non_filing = nil
-        end
-        append_title_variant_field(acc, non_filing, parts)
-      end
-    end
-
-    def get_title_1_search_main_values(rec, format_filter: false)
-      format = get_format_from_leader(rec)
-      acc = rec.fields('245').map do |field|
-        if !format_filter || format.end_with?('s')
-          join_and_trim_whitespace(field.find_all(&subfield_not_in(%w{c 6 8 h})).map(&:value))
-        end
-      end.select { |v| v.present? }
-      acc += rec.fields('880')
-                .select { |f| has_subfield6_value(f, /^245/) }
-                .map do |field|
-        if !format_filter || format.end_with?('s')
-          join_and_trim_whitespace(field.find_all(&subfield_not_in(%w{c 6 8 h})).map(&:value))
-        end
-      end.select { |v| v.present? }
-      acc
-    end
-
-    def get_title_1_search_values(rec)
-      get_title_1_search_main_values(rec)
-    end
-
-    def get_journal_title_1_search_values(rec)
-      get_title_1_search_main_values(rec, format_filter: true)
-    end
-
-    def title_2_search_main_tags
-      @title_2_search_main_tags ||= %w{130 210 240 245 246 247 440 490 730 740 830}
-    end
-
-    def title_2_search_aux_tags
-      @title_2_search_aux_tags ||= %w{773 774 780 785}
-    end
-
-    def title_2_search_7xx_tags
-      @title_2_search_7xx_tags ||= %w{700 710 711}
-    end
-
-    def get_title_2_search_main_values(rec, format_filter: false)
-      format = get_format_from_leader(rec)
-      rec.fields(title_2_search_main_tags).map do |field|
-        if !format_filter || format.end_with?('s')
-          join_and_trim_whitespace(field.find_all(&subfield_not_in(%w{c 6 8})).map(&:value))
-        end
-      end.select { |v| v.present? }
-    end
-
-    def get_title_2_search_aux_values(rec, format_filter: false)
-      format = get_format_from_leader(rec)
-      rec.fields(title_2_search_aux_tags).map do |field|
-        if !format_filter || format.end_with?('s')
-          join_and_trim_whitespace(field.find_all(&subfield_not_in(%w{s t})).map(&:value))
-        end
-      end.select { |v| v.present? }
-    end
-
-    def get_title_2_search_7xx_values(rec, format_filter: false)
-      format = get_format_from_leader(rec)
-      rec.fields(title_2_search_7xx_tags).map do |field|
-        if !format_filter || format.end_with?('s')
-          join_and_trim_whitespace(field.find_all(&subfield_in(%w{t})).map(&:value))
-        end
-      end.select { |v| v.present? }
-    end
-
-    def get_title_2_search_505_values(rec, format_filter: false)
-      format = get_format_from_leader(rec)
-      rec.fields('505')
-         .select { |f| f.indicator1 == '0' && f.indicator2 == '0' }
-         .map do |field|
-        if !format_filter || format.end_with?('s')
-          join_and_trim_whitespace(field.find_all(&subfield_in(%w{t})).map(&:value))
-        end
-      end.select { |v| v.present? }
-    end
-
-    def get_title_2_search_800_values(rec, format_filter: false)
-      format = get_format_from_leader(rec)
-      acc = []
-      acc += rec.fields('880')
-                .select { |f| f.any? { |sf| sf.code =='6' && sf.value =~ /^(130|210|240|245|246|247|440|490|730|740|830)/ } }
-                .map do |field|
-        if !format_filter || format.end_with?('s')
-          join_and_trim_whitespace(field.find_all(&subfield_not_in(%w{c 6 8 h})).map(&:value))
-        end
-      end.select { |v| v.present? }
-      acc += rec.fields('880')
-                .select { |f| f.any? { |sf| sf.code =='6' && sf.value =~ /^(773|774|780|785)/ } }
-                .map do |field|
-        if !format_filter || format.end_with?('s')
-          join_and_trim_whitespace(field.find_all(&subfield_in(%w{s t})).map(&:value))
-        end
-      end.select { |v| v.present? }
-      acc += rec.fields('880')
-                .select { |f| f.any? { |sf| sf.code =='6' && sf.value =~ /^(700|710|711)/ } }
-                .map do |field|
-        if !format_filter || format.end_with?('s')
-          join_and_trim_whitespace(field.find_all(&subfield_in(%w{t})).map(&:value))
-        end
-      end.select { |v| v.present? }
-      acc += rec.fields('880')
-                .select { |f| f.indicator1 == '0' && f.indicator2 == '0' }
-                .select { |f| f.any? { |sf| sf.code =='6' && sf.value =~ /^505/ } }
-                .map do |field|
-        if !format_filter || format.end_with?('s')
-          join_and_trim_whitespace(field.find_all(&subfield_in(%w{t})).map(&:value))
-        end
-      end.select { |v| v.present? }
-      acc
-    end
-
-    def get_title_2_search_values(rec)
-      get_title_2_search_main_values(rec) +
-        get_title_2_search_aux_values(rec) +
-        get_title_2_search_7xx_values(rec) +
-        get_title_2_search_505_values(rec) +
-        get_title_2_search_800_values(rec)
-    end
-
-    def get_journal_title_2_search_values(rec)
-      get_title_2_search_main_values(rec, format_filter: true) +
-        get_title_2_search_aux_values(rec, format_filter: true) +
-        get_title_2_search_7xx_values(rec, format_filter: true) +
-        get_title_2_search_505_values(rec, format_filter: true) +
-        get_title_2_search_800_values(rec, format_filter: true)
-    end
-
-    # this gets called directly by ShowPresenter rather than via
-    # Blacklight's show field definition plumbing, so we return a single string
-    def get_title_display(rec)
-      acc = []
-      acc += rec.fields('245').map do |field|
-        join_subfields(field, &subfield_not_in(%w{6 8}))
-      end
-      acc += get_880(rec, '245', &subfield_not_in(%w{6 8}))
-               .map { |value| " = #{value}" }
-      acc.join(' ')
-    end
-
-    def author_creator_tags
-      @author_creator_tags ||= %w{100 110}
-    end
-
-    def get_author_creator_values(rec)
-      rec.fields(author_creator_tags).map do |field|
-        get_name_1xx_field(field)
-      end
-    end
-
-    def get_author_880_values(rec)
-      rec.fields('880')
-         .select { |f| has_subfield6_value(f, /^(100|110)/) }
-         .map do |field|
-        join_and_trim_whitespace(field.find_all(&subfield_not_in(%w{4 6 8})).map(&:value))
-      end
-    end
-
-    def get_author_creator_1_search_values(rec)
-      acc = []
-      acc += rec.fields(%w{100 110}).map do |field|
-        pieces = field.map do |sf|
-          if sf.code == 'a'
-            after_comma = join_and_trim_whitespace([ trim_trailing_comma(substring_after(sf.value, ', ')) ])
-            before_comma = substring_before(sf.value, ', ')
-            " #{after_comma} #{before_comma}"
-          elsif !%W{a 1 4 6 8}.member?(sf.code)
-            " #{sf.value}"
-          elsif sf.code == '4'
-            ", #{relator_codes[sf.value]}"
-          end
-        end.compact
-        value = join_and_trim_whitespace(pieces)
-        if value.end_with?('.') || value.end_with?('-')
-          value
-        else
-          value + '.'
-        end
-      end
-      acc += rec.fields(%w{100 110}).map do |field|
-        pieces = field.map do |sf|
-          if(! %W{4 6 8}.member?(sf.code))
-            " #{sf.value}"
-          elsif sf.code == '4'
-            ", #{relator_codes[sf.value]}"
-          end
-        end.compact
-        value = join_and_trim_whitespace(pieces)
-        if value.end_with?('.') || value.end_with?('-')
-          value
-        else
-          value + '.'
-        end
-      end
-      acc += rec.fields(%w{880})
-                .select { |f| f.any? { |sf| sf.code =='6' && sf.value =~ /^(100|110)/ } }
-                .map do |field|
-        suba = field.find_all(&subfield_in(%w{a})).map do |sf|
-          after_comma = join_and_trim_whitespace([ trim_trailing_comma(substring_after(sf.value, ',')) ])
-          before_comma = substring_before(sf.value, ',')
-          "#{after_comma} #{before_comma}"
-        end.first
-        oth = join_and_trim_whitespace(field.find_all(&subfield_not_in(%w{6 8 a t})).map(&:value))
-        [suba, oth].join(' ')
-      end
-      acc
-    end
-
-    def author_creator_2_tags
-      @author_creator_2_tags ||= %w{100 110 111 400 410 411 700 710 711 800 810 811}
-    end
-
-    def get_author_creator_2_search_values(rec)
-      acc = []
-      acc += rec.fields(author_creator_2_tags).map do |field|
-        pieces1 = field.map do |sf|
-          if !%W{1 4 5 6 8 t}.member?(sf.code)
-            " #{sf.value}"
-          elsif sf.code == '4'
-            ", #{relator_codes[sf.value]}"
-          end
-        end.compact
-        value1 = join_and_trim_whitespace(pieces1)
-        if value1.end_with?('.') || value1.end_with?('-')
-          value1
-        else
-          value1 + '.'
-        end
-
-        pieces2 = field.map do |sf|
-          if sf.code == 'a'
-            after_comma = join_and_trim_whitespace([ trim_trailing_comma(substring_after(sf.value, ', ')) ])
-            before_comma = substring_before(sf.value, ',')
-            " #{after_comma} #{before_comma}"
-          elsif(! %W{a 4 5 6 8 t}.member?(sf.code))
-            " #{sf.value}"
-          elsif sf.code == '4'
-            ", #{relator_codes[sf.value]}"
-          end
-        end.compact
-        value2 = join_and_trim_whitespace(pieces2)
-        if value2.end_with?('.') || value2.end_with?('-')
-          value2
-        else
-          value2 + '.'
-        end
-
-        [ value1, value2 ]
-      end.flatten(1)
-      acc += rec.fields(%w{880})
-                .select { |f| f.any? { |sf| sf.code =='6' && sf.value =~ /^(100|110|111|400|410|411|700|710|711|800|810|811)/ } }
-                .map do |field|
-        value1 = join_and_trim_whitespace(field.find_all(&subfield_not_in(%w{5 6 8 t})).map(&:value))
-
-        suba = field.find_all(&subfield_in(%w{a})).map do |sf|
-          after_comma = join_and_trim_whitespace([ trim_trailing_comma(substring_after(sf.value, ',')) ])
-          before_comma = substring_before(sf.value, ',')
-          "#{after_comma} #{before_comma}"
-        end.first
-        oth = join_and_trim_whitespace(field.find_all(&subfield_not_in(%w{5 6 8 a t})).map(&:value))
-        value2 = [ suba, oth ].join(' ')
-
-        [ value1, value2 ]
-      end.flatten(1)
-      acc
-    end
-
-    def get_author_creator_sort_values(rec)
-      rec.fields(author_creator_tags).take(1).map do |field|
-        join_subfields(field, &subfield_not_in(%w[1 4 6 8 e]))
-      end
-    end
-
-    def get_author_display(rec)
-      acc = []
-      rec.fields(%w{100 110}).each do |field|
-        subf4 = get_subfield_4ew(field)
-        author_parts = []
-        field.each do |sf|
-          # added 2017/04/10: filter out 0 (authority record numbers) added by Alma
-          # added 2022/08/04: filter out 1 (URIs) added by MARCive project
-          if !%W{0 1 4 6 8 e w}.member?(sf.code)
-            author_parts << sf.value
-          end
-        end
-        acc << {
-          value: author_parts.join(' '),
-          value_append: subf4,
-          link_type: 'author_creator_xfacet2' }
-      end
-      rec.fields('880').each do |field|
-        if has_subfield6_value(field, /^(100|110)/)
-          subf4 = get_subfield_4ew(field)
-          author_parts = []
-          field.each do |sf|
-            # added 2017/04/10: filter out 0 (authority record numbers) added by Alma
-            unless %W{0 4 6 8 e w}.member?(sf.code)
-              author_parts << sf.value.gsub(/\?$/, '')
-            end
-          end
-          acc << {
-            value: author_parts.join(' '),
-            value_append: subf4,
-            link_type: 'author_creator_xfacet2' }
-        end
-      end
-      acc
-    end
-
-    def get_corporate_author_search_values(rec)
-      rec.fields(%w{110 710 810}).map do |field|
-        join_and_trim_whitespace(field.select(&subfield_in(%w{a b c d})).map(&:value))
-      end
-    end
-
-    def get_standardized_title_values(rec)
-      rec.fields(%w{130 240}).map do |field|
-        # added 2017/05/15: filter out 0 (authority record numbers) added by Alma
-        results = field.find_all(&subfield_not_in(%W{0 6 8})).map(&:value)
-        join_and_trim_whitespace(results)
-      end
-    end
-
-    def get_standardized_title_display(rec)
-      acc = []
-      rec.fields(%w{130 240}).each do |field|
-        # added 2017/05/15: filter out 0 (authority record numbers) added by Alma
-        title = join_subfields(field, &subfield_not_in(%W{0 6 8 e w}))
-        title_param_value = join_subfields(field, &subfield_not_in(%W{0 5 6 8 e w}))
-        title_append = get_title_extra(field)
-        acc << {
-          value: title,
-          value_for_link: title_param_value,
-          value_append: title_append,
-          link_type: 'title_search' }
-      end
-      rec.fields('730')
-         .select { |f| f.indicator1 == '' || f.indicator2 == '' }
-         .select { |f| f.none? { |sf| sf.code == 'i'} }
-         .each do |field|
-        title = join_subfields(field, &subfield_not_in(%w{5 6 8 e w}))
-        title_append = get_title_extra(field)
-        acc << {
-          value: title,
-          value_append: title_append,
-          link_type: 'title_search' }
-      end
-      rec.fields('880')
-         .select { |f| has_subfield6_value(f, /^(130|240|730)/) }
-         .select { |f| f.none? { |sf| sf.code == 'i'} }
-         .each do |field|
-        title = join_subfields(field, &subfield_not_in(%w{5 6 8 e w}))
-        title_append = get_title_extra(field)
-        acc << {
-          value: title,
-          value_append: title_append,
-          link_type: 'title_search' }
-      end
-      acc
-    end
-
-    def get_edition_values(rec)
-      rec.fields('250').take(1).map do |field|
-        results = field.find_all(&subfield_not_in(%w{6 8})).map(&:value)
-        join_and_trim_whitespace(results)
-      end
-    end
-
-    def get_edition_display(rec)
-      acc = []
-      acc += rec.fields('250').map do |field|
-        join_subfields(field, &subfield_not_in(%W{6 8}))
-      end
-      acc += rec.fields('880')
-                .select { |f| has_subfield6_value(f, /^250/)}
-                .map do |field|
-        join_subfields(field, &subfield_not_in(%W{6 8}))
-      end
-      acc
-    end
-
-    def get_conference_values(rec)
-      rec.fields('111').map do |field|
-        get_name_1xx_field(field)
-      end
-    end
-
-    def get_conference_search_values(rec)
-      rec.fields(%w{111 711 811}).map do |field|
-        join_and_trim_whitespace(field.select(&subfield_in(%w{a c d e})).map(&:value))
-      end
-    end
-
-    def get_conference_display(rec)
-      results = rec.fields(%w{111 711})
-                   .select{ |f| ['', ' '].member?(f.indicator2) }
-                   .map do |field|
-        conf = ''
-        if field.none? { |sf| sf.code == 'i' }
-          # added 2017/05/18: filter out 0 (authority record numbers) added by Alma
-          conf = join_subfields(field, &subfield_not_in(%w{0 4 5 6 8 e j w}))
-        end
-        conf_append = join_subfields(field, &subfield_in(%w{e j w}))
-        { value: conf, value_append: conf_append, link_type: 'author_creator_xfacet2' }
-      end
-      results += rec.fields('880')
-                    .select { |f| has_subfield6_value(f, /^(111|711)/) }
-                    .select { |f| f.none? { |sf| sf.code == 'i' } }
-                    .map do |field|
-        # added 2017/05/18: filter out 0 (authority record numbers) added by Alma
-        conf = join_subfields(field, &subfield_not_in(%w{0 4 5 6 8 e j w}))
-        conf_extra = join_subfields(field, &subfield_in(%w{4 e j w}))
-        { value: conf, value_append: conf_extra, link_type: 'author_creator_xfacet2' }
-      end
-      results
-    end
-
-    def get_series_values(rec)
-      acc = []
-      added_8xx = false
-      rec.fields(%w{800 810 811 830}).take(1).each do |field|
-        acc << get_series_8xx_field(field)
-        added_8xx = true
-      end
-      if !added_8xx
-        rec.fields(%w{400 410 411 440 490}).take(1).map do |field|
-          acc << get_series_4xx_field(field)
-        end
-      end
-      acc
-    end
-
-    def series_tags
-      @series_tags ||= %w{800 810 811 830 400 411 440 490}
-    end
-
-    def get_series_display(rec)
-      acc = []
-
-      tags_present = series_tags.select { |tag| rec[tag].present? }
-
-      if %w{800 810 811 400 410 411}.member?(tags_present.first)
-        rec.fields(tags_present.first).each do |field|
-          # added 2017/04/10: filter out 0 (authority record numbers) added by Alma
-          series = join_subfields(field, &subfield_not_in(%w{0 5 6 8 e t w v n}))
-          pairs = field.map do |sf|
-            if %w{e w v n t}.member?(sf.code)
-              [ ' ', sf.value ]
-            elsif sf.code == '4'
-              [ ', ', relator_codes[sf.value] ]
-            end
-          end
-          series_append = pairs.flatten.join.strip
-          acc << { value: series, value_append: series_append, link_type: 'author_search' }
-        end
-      elsif %w{830 440 490}.member?(tags_present.first)
-        rec.fields(tags_present.first).each do |field|
-          # added 2017/04/10: filter out 0 (authority record numbers) added by Alma
-          series = join_subfields(field, &subfield_not_in(%w{0 5 6 8 c e w v n}))
-          series_append = join_subfields(field, &subfield_in(%w{c e w v n}))
-          acc << { value: series, value_append: series_append, link_type: 'title_search' }
-        end
-      end
-
-      rec.fields(tags_present.drop(1)).each do |field|
-        # added 2017/04/10: filter out 0 (authority record numbers) added by Alma
-        series = join_subfields(field, &subfield_not_in(%w{0 5 6 8}))
-        acc << { value: series, link: false }
-      end
-
-      rec.fields('880')
-         .select { |f| has_subfield6_value(f, /^(800|810|811|830|400|410|411|440|490)/) }
-         .each do |field|
-        series = join_subfields(field, &subfield_not_in(%W{5 6 8}))
-        acc << { value: series, link: false }
-      end
-
-      acc
-    end
-
-    def get_series_search_values(rec)
-      acc = []
-      acc += rec.fields(%w{400 410 411})
-                .select { |f| f.indicator2 == '0' }
-                .map do |field|
-        join_subfields(field, &subfield_not_in(%w{4 6 8}))
-      end
-      acc += rec.fields(%w{400 410 411})
-                .select { |f| f.indicator2 == '1' }
-                .map do |field|
-        join_subfields(field, &subfield_not_in(%w{4 6 8 a}))
-      end
-      acc += rec.fields(%w{440})
-                .map do |field|
-        join_subfields(field, &subfield_not_in(%w{0 5 6 8 w}))
-      end
-      acc += rec.fields(%w{800 810 811})
-                .map do |field|
-        join_subfields(field, &subfield_not_in(%w{0 4 5 6 7 8 w}))
-      end
-      acc += rec.fields(%w{830})
-                .map do |field|
-        join_subfields(field, &subfield_not_in(%w{0 5 6 7 8 w}))
-      end
-      acc += rec.fields(%w{533})
-                .map do |field|
-        field.find_all { |sf| sf.code == 'f' }
-             .map(&:value)
-             .map { |v| v.gsub(/\(|\)/, '') }
-             .join(' ')
-      end
-      acc
-    end
-
-    def get_contained_within_values(rec)
-      rec.fields('773').map do |field|
-        results = field.find_all(&subfield_not_in(%w{6 7 8 w})).map(&:value)
-        join_and_trim_whitespace(results)
-      end
-    end
-
-    # @return [Array] of hashes each describing a physical holding
-    def get_physical_holdings(rec)
-      # enriched MARC looks like this:
-      # <datafield tag="hld" ind1="0" ind2=" ">
-      #   <subfield code="b">MAIN</subfield>
-      #   <subfield code="c">main</subfield>
-      #   <subfield code="h">NA2540</subfield>
-      #   <subfield code="i">.G63 2009</subfield>
-      #   <subfield code="8">226026380000541</subfield>
-      # </datafield>
-      rec.fields(EnrichedMarc::TAG_HOLDING).map do |item|
-        # Alma never populates subfield 'a' which is 'location'
-        # it appears to store the location code in 'c'
-        # and display name in 'b'
-        {
-          holding_id: item[EnrichedMarc::SUB_HOLDING_SEQUENCE_NUMBER],
-          location: item[EnrichedMarc::SUB_HOLDING_SHELVING_LOCATION],
-          classification_part: item[EnrichedMarc::SUB_HOLDING_CLASSIFICATION_PART],
-          item_part: item[EnrichedMarc::SUB_HOLDING_ITEM_PART],
-        }
-      end
-    end
-
-    # @return [Array] of hashes each describing an electronic holding
-    def get_electronic_holdings(rec)
-      # enriched MARC looks like this:
-      # <datafield tag="prt" ind1=" " ind2=" ">
-      #   <subfield code="pid">5310486800000521</subfield>
-      #   <subfield code="url">https://sandbox01-na.alma.exlibrisgroup.com/view/uresolver/01UPENN_INST/openurl?u.ignore_date_coverage=true&amp;rft.mms_id=9926519600521</subfield>
-      #   <subfield code="iface">PubMed Central</subfield>
-      #   <subfield code="coverage"> Available from 2005 volume: 1. Most recent 1 year(s) not available.</subfield>
-      #   <subfield code="library">MAIN</subfield>
-      #   <subfield code="collection">PubMed Central (Training)</subfield>
-      #   <subfield code="czcolid">61111058563444000</subfield>
-      #   <subfield code="8">5310486800000521</subfield>
-      # </datafield>
-
-      # do NOT index electronic holdings where collection name is blank:
-      # these are records created from 856 fields from Voyager
-      # that don't have actual links.
-
-      rec.fields(EnrichedMarc::TAG_ELECTRONIC_INVENTORY)
-         .select { |item| item[EnrichedMarc::SUB_ELEC_COLLECTION_NAME].present? }
-         .map do |item|
-        {
-          portfolio_pid: item[EnrichedMarc::SUB_ELEC_PORTFOLIO_PID],
-          url: item[EnrichedMarc::SUB_ELEC_ACCESS_URL],
-          collection: item[EnrichedMarc::SUB_ELEC_COLLECTION_NAME],
-          coverage: item[EnrichedMarc::SUB_ELEC_COVERAGE],
-        }
-      end
-    end
-
-    def get_bound_with_id_values(rec)
-      rec.fields(EnrichedMarc::TAG_HOLDING).flat_map do |field|
-        field.select(&subfield_in([ EnrichedMarc::SUB_BOUND_WITH_ID ])).map { |sf| sf.value }
-      end
-    end
-
-    def get_subfield_4ew(field)
-      field.select(&subfield_in(%W{4 e w}))
-           .map { |sf| (sf.code == '4' ? ", #{relator_codes[sf.value]}" : " #{sf.value}") }
-           .join('')
-    end
-
-    def get_title_extra(field)
-      join_subfields(field, &subfield_in(%W{e w}))
-    end
-
-    def get_other_title_display(rec)
-      acc = []
-      acc += rec.fields('246').map do |field|
-        join_subfields(field, &subfield_not_in(%W{6 8}))
-      end
-      acc += rec.fields('740')
-                .select { |f| ['', ' ', '0', '1', '3'].member?(f.indicator2) }
-                .map do |field|
-        join_subfields(field, &subfield_not_in(%W{5 6 8}))
-      end
-      acc += rec.fields('880')
-                .select { |f| has_subfield6_value(f, /^(246|740)/) }
-                .map do |field|
-        join_subfields(field, &subfield_not_in(%W{5 6 8}))
-      end
-      acc
-    end
-
-    # distribution and manufacture share the same logic except for indicator2
-    def get_264_or_880_fields(rec, indicator2)
-      acc = []
-      acc += rec.fields('264')
-                .select { |f| f.indicator2 == indicator2 }
-                .map do |field|
-        join_subfields(field, &subfield_in(%w{a b c}))
-      end
-      acc += rec.fields('880')
-                .select { |f| f.indicator2 == indicator2 }
-                .select { |f| has_subfield6_value(f, /^264/) }
-                .map do |field|
-        join_subfields(field, &subfield_in(%w{a b c}))
-      end
-      acc
-    end
-
-    def get_production_display(rec)
-      get_264_or_880_fields(rec, '0')
-    end
-
-    def get_distribution_display(rec)
-      get_264_or_880_fields(rec, '2')
-    end
-
-    def get_manufacture_display(rec)
-      get_264_or_880_fields(rec, '3')
-    end
-
-    def get_cartographic_display(rec)
-      rec.fields(%w{255 342}).map do |field|
-        join_subfields(field, &subfield_not_6_or_8)
-      end
-    end
-
-    def get_fingerprint_display(rec)
-      rec.fields('026').map do |field|
-        join_subfields(field, &subfield_not_in(%w{2 5 6 8}))
-      end
-    end
-
-    def get_arrangement_display(rec)
-      get_datafield_and_880(rec, '351')
-    end
-
-    def get_former_title_display(rec)
-      rec.fields
-         .select { |f| f.tag == '247' || (f.tag == '880' && has_subfield6_value(f, /^247/)) }
-         .map do |field|
-        former_title = join_subfields(field, &subfield_not_in(%w{6 8 e w}))
-        former_title_append = join_subfields(field, &subfield_in(%w{e w}))
-        { value: former_title, value_append: former_title_append, link_type: 'title_search' }
-      end
-    end
-
-    # logic for 'Continues' and 'Continued By' is very similar
-    def get_continues(rec, tag)
-      rec.fields
-         .select { |f| f.tag == tag || (f.tag == '880' && has_subfield6_value(f, /^#{tag}/)) }
-         .select { |f| f.any?(&subfield_in(%w{i a s t n d})) }
-         .map do |field|
-        join_subfields(field, &subfield_in(%w{i a s t n d}))
-      end
-    end
-
-    def get_continues_display(rec)
-      get_continues(rec, '780')
-    end
-
-    def get_continued_by_display(rec)
-      get_continues(rec, '785')
-    end
-
-    def get_place_of_publication_display(rec)
-      acc = []
-      acc += rec.fields('752').map do |field|
-        place = join_subfields(field, &subfield_not_in(%w{6 8 e w}))
-        place_extra = join_subfields(field, &subfield_in(%w{e w}))
-        { value: place, value_append: place_extra, link_type: 'search' }
-      end
-      acc += get_880_subfield_not_6_or_8(rec, '752').map do |result|
-        { value: result, link: false }
-      end
-      acc
-    end
-
-    def get_language_display(rec)
-      get_datafield_and_880(rec, '546')
-    end
-
-    # for system details: extract subfield 3 plus other subfields as specified by passed-in block
-    def get_sub3_and_other_subs(field, &block)
-      sub3 = field.select(&subfield_in(%w{3})).map(&:value).map { |v| trim_trailing_period(v) }.join(': ')
-      oth_subs = join_subfields(field, &block)
-      [ sub3, trim_trailing_semicolon(oth_subs) ].join(' ')
-    end
-
-    def get_system_details_display(rec)
-      acc = []
-      acc += rec.fields('538').map do |field|
-        get_sub3_and_other_subs(field, &subfield_in(%w{a i u}))
-      end
-      acc += rec.fields('344').map do |field|
-        get_sub3_and_other_subs(field, &subfield_in(%w{a b c d e f g h}))
-      end
-      acc += rec.fields(%w{345 346}).map do |field|
-        get_sub3_and_other_subs(field, &subfield_in(%w{a b}))
-      end
-      acc += rec.fields('347').map do |field|
-        get_sub3_and_other_subs(field, &subfield_in(%w{a b c d e f}))
-      end
-      acc += rec.fields('880')
-                .select { |f| has_subfield6_value(f, /^538/) }
-                .map do |field|
-        get_sub3_and_other_subs(field, &subfield_in(%w{a i u}))
-      end
-      acc += rec.fields('880')
-                .select { |f| has_subfield6_value(f, /^344/) }
-                .map do |field|
-        get_sub3_and_other_subs(field, &subfield_in(%w{a b c d e f g h}))
-      end
-      acc += rec.fields('880')
-                .select { |f| has_subfield6_value(f, /^(345|346)/) }
-                .map do |field|
-        get_sub3_and_other_subs(field, &subfield_in(%w{a b}))
-      end
-      acc += rec.fields('880')
-                .select { |f| has_subfield6_value(f, /^347/) }
-                .map do |field|
-        get_sub3_and_other_subs(field, &subfield_in(%w{a b c d e f}))
-      end
-      acc
-    end
-
-    def get_biography_display(rec)
-      get_datafield_and_880(rec, '545')
-    end
-
-    def get_summary_display(rec)
-      get_datafield_and_880(rec, '520')
-    end
-
-    def get_contents_display(rec)
-      acc = []
-      acc += rec.fields('505').flat_map do |field|
-        join_subfields(field, &subfield_not_6_or_8).split('--')
-      end
-      acc += rec.fields('880')
-                .select { |f| has_subfield6_value(f, /^505/) }
-                .flat_map do |field|
-        join_subfields(field, &subfield_not_6_or_8).split('--')
-      end
-      acc
-    end
-
-    def get_contents_note_search_values(rec)
-      rec.fields('505').map do |field|
-        join_and_trim_whitespace(field.to_a.map(&:value))
-      end
-    end
-
-    def get_participant_display(rec)
-      get_datafield_and_880(rec, '511')
-    end
-
-    def get_credits_display(rec)
-      get_datafield_and_880(rec, '508')
-    end
-
-    # 10/2018 kms: add 586
-    def get_notes_display(rec)
-      acc = []
-      acc += rec.fields(%w{500 502 504 515 518 525 533 550 580 586 588}).map do |field|
-        if field.tag == '588'
-          join_subfields(field, &subfield_in(%w{a}))
-        else
-          join_subfields(field, &subfield_not_in(%w{5 6 8}))
-        end
-      end
-      acc += rec.fields('880')
-                .select { |f| has_subfield6_value(f, /^(500|502|504|515|518|525|533|550|580|586|588)/) }
-                .map do |field|
-        sub6 = field.select(&subfield_in(%w{6})).map(&:value).first
-        if sub6 == '588'
-          join_subfields(field, &subfield_in(%w{a}))
-        else
-          join_subfields(field, &subfield_not_in(%w{5 6 8}))
-        end
-      end
-      acc
-    end
-
-    # 10/2018 kms: add 562 563 585. Add 561 if subf a starts with Athenaeum copy:
-    # non-Athenaeum 561 still displays as Penn Provenance
-    def get_local_notes_display(rec)
-      acc = []
-      acc += rec.fields('561')
-                .select { |f| f.any?{ |sf| sf.code == 'a' && sf.value =~ /^Athenaeum copy: / } }
-                .map do |field|
-        join_subfields(field, &subfield_in(%w{a}))
-      end
-      acc += rec.fields(%w{562 563 585 590}).map do |field|
-        join_subfields(field, &subfield_not_in(%w{5 6 8}))
-      end
-      acc += get_880(rec, %w{562 563 585 590}) do |sf|
-        ! %w{5 6 8}.member?(sf.code)
-      end
-      acc
-    end
-
-    def get_finding_aid_display(rec)
-      get_datafield_and_880(rec, '555')
-    end
-
-    # get 650/880 for provenance and chronology: prefix should be 'PRO' or 'CHR'
-    # 11/2018: do not display $5 in PRO or CHR subjs
-    def get_650_and_880(rec, prefix)
-      acc = []
-      acc += rec.fields('650')
-                .select { |f| f.indicator2 == '4' }
-                .select { |f| f.any? { |sf| sf.code == 'a' && sf.value =~ /^(#{prefix}|%#{prefix})/ } }
-                .map do |field|
-        suba = field.select(&subfield_in(%w{a})).map {|sf|
-          sf.value.gsub(/^%?#{prefix}/, '')
-        }.join(' ')
-        sub_others = join_subfields(field, &subfield_not_in(%w{a 6 8 e w 5}))
-        value = [ suba, sub_others ].join(' ')
-        { value: value, link_type: 'subject_search' } if value.present?
-      end.compact
-      acc += rec.fields('880')
-                .select { |f| f.indicator2 == '4' }
-                .select { |f| has_subfield6_value(f,/^650/) }
-                .select { |f| f.any? { |sf| sf.code == 'a' && sf.value =~ /^(#{prefix}|%#{prefix})/ } }
-                .map do |field|
-        suba = field.select(&subfield_in(%w{a})).map {|sf| sf.value.gsub(/^%?#{prefix}/, '') }.join(' ')
-        sub_others = join_subfields(field, &subfield_not_in(%w{a 6 8 e w 5}))
-        value = [ suba, sub_others ].join(' ')
-        { value: value, link_type: 'subject_search' } if value.present?
-      end.compact
-      acc
-    end
-
-    # 11/2018 kms: a 561 starting Athenaeum copy: should not appear as Penn Provenance, display that as Local Notes
-    def get_provenance_display(rec)
-      acc = []
-      acc += rec.fields('561')
-                .select { |f| ['1', '', ' '].member?(f.indicator1) && [' ', ''].member?(f.indicator2) && f.any?{ |sf| sf.code == 'a' && sf.value !~ /^Athenaeum copy: / }  }
-                .map do |field|
-        value = join_subfields(field, &subfield_in(%w{a}))
-        { value: value, link: false } if value
-      end.compact
-      acc += rec.fields('880')
-                .select { |f| has_subfield6_value(f, /^561/) }
-                .select { |f| ['1', '', ' '].member?(f.indicator1) && [' ', ''].member?(f.indicator2) }
-                .map do |field|
-        value = join_subfields(field, &subfield_in(%w{a}))
-        { value: value, link: false } if value
-      end.compact
-      acc += get_650_and_880(rec, 'PRO')
-      acc
-    end
-
-    def get_chronology_display(rec)
-      get_650_and_880(rec, 'CHR')
-    end
-
-    def get_related_collections_display(rec)
-      get_datafield_and_880(rec, '544')
-    end
-
-    def get_cited_in_display(rec)
-      get_datafield_and_880(rec, '510')
-    end
-
-    def get_publications_about_display(rec)
-      get_datafield_and_880(rec, '581')
-    end
-
-    def get_cite_as_display(rec)
-      get_datafield_and_880(rec, '524')
-    end
-
-    def get_contributor_display(rec)
-      acc = []
-      acc += rec.fields(%w{700 710})
-                .select { |f| ['', ' ', '0'].member?(f.indicator2) }
-                .select { |f| f.none? { |sf| sf.code == 'i' } }
-                .map do |field|
-        contributor = join_subfields(field, &subfield_in(%w{a b c d j q}))
-        contributor_append = field.select(&subfield_in(%w{e u 3 4})).map do |sf|
-          if sf.code == '4'
-            ", #{relator_codes[sf.value]}"
-          else
-            " #{sf.value}"
-          end
-        end.join
-        { value: contributor, value_append: contributor_append, link_type: 'author_creator_xfacet2' }
-      end
-      acc += rec.fields('880')
-                .select { |f| has_subfield6_value(f, /^(700|710)/) && (f.none? { |sf| sf.code == 'i' }) }
-                .map do |field|
-        contributor = join_subfields(field, &subfield_in(%w{a b c d j q}))
-        contributor_append = join_subfields(field, &subfield_in(%w{e u 3}))
-        { value: contributor, value_append: contributor_append, link_type: 'author_creator_xfacet2' }
-      end
-      acc
-    end
-
-    # if there's a subfield i, extract its value, and if there's something
-    # in parentheses in that value, extract that.
-    def remove_paren_value_from_subfield_i(field)
-      val = field.select { |sf| sf.code == 'i' }.map do |sf|
-        match = /\((.+?)\)/.match(sf.value)
-        if match
-          sf.value.sub('(' + match[1] + ')', '')
-        else
-          sf.value
-        end
-      end.first || ''
-      trim_trailing_colon(trim_trailing_period(val))
-    end
-
-    def get_related_work_display(rec)
-      acc = []
-      acc += rec.fields(%w{700 710 711 730})
-                .select { |f| ['', ' '].member?(f.indicator2) }
-                .select { |f| f.any? { |sf| sf.code == 't' } }
-                .map do |field|
-        subi = remove_paren_value_from_subfield_i(field) || ''
-        related = field.map do |sf|
-          if ! %w{0 4 i}.member?(sf.code)
-            " #{sf.value}"
-          elsif sf.code == '4'
-            ", #{relator_codes[sf.value]}"
-          end
-        end.compact.join
-        [ subi, related ].select(&:present?).join(':')
-      end
-      acc += rec.fields('880')
-                .select { |f| ['', ' '].member?(f.indicator2) }
-                .select { |f| has_subfield6_value(f, /^(700|710|711|730)/) }
-                .select { |f| f.any? { |sf| sf.code == 't' } }
-                .map do |field|
-        subi = remove_paren_value_from_subfield_i(field) || ''
-        related = field.map do |sf|
-          if ! %w{0 4 i}.member?(sf.code)
-            " #{sf.value}"
-          elsif sf.code == '4'
-            ", #{relator_codes[sf.value]}"
-          end
-        end.compact.join
-        [ subi, related ].select(&:present?).join(':')
-      end
-      acc
-    end
-
-    def get_contains_display(rec)
-      acc = []
-      acc += rec.fields(%w{700 710 711 730 740})
-                .select { |f| f.indicator2 == '2' }
-                .map do |field|
-        subi = remove_paren_value_from_subfield_i(field) || ''
-        contains = field.map do |sf|
-          if ! %w{0 4 5 6 8 i}.member?(sf.code)
-            " #{sf.value}"
-          elsif sf.code == '4'
-            ", #{relator_codes[sf.value]}"
-          end
-        end.compact.join
-        [ subi, contains ].select(&:present?).join(':')
-      end
-      acc += rec.fields('880')
-                .select { |f| f.indicator2 == '2' }
-                .select { |f| has_subfield6_value(f, /^(700|710|711|730|740)/) }
-                .map do |field|
-        subi = remove_paren_value_from_subfield_i(field) || ''
-        contains = join_subfields(field, &subfield_not_in(%w{0 5 6 8 i}))
-        [ subi, contains ].select(&:present?).join(':')
-      end
-      acc
-    end
-
-    def get_other_edition_value(field)
-      subi = remove_paren_value_from_subfield_i(field) || ''
-      other_editions = field.map do |sf|
-        if %w{s x z}.member?(sf.code)
-          " #{sf.value}"
-        elsif sf.code == 't'
-          " #{relator_codes[sf.value]}. "
-        end
-      end.compact.join
-      other_editions_append = field.map do |sf|
-        if ! %w{i h s t x z e f o r w y 7}.member?(sf.code)
-          " #{sf.value}"
-        elsif sf.code == 'h'
-          " (#{sf.value}) "
-        end
-      end.compact.join
-      {
-        value: other_editions,
-        value_prepend: trim_trailing_period(subi) + ':',
-        value_append: other_editions_append,
-        link_type: 'author_creator_xfacet2'
-      }
-    end
-
-    def get_other_edition_display(rec)
-      acc = []
-      acc += rec.fields('775')
-                .select { |f| f.any? { |sf| sf.code == 'i' } }
-                .map do |field|
-        get_other_edition_value(field)
-      end
-      acc += rec.fields('880')
-                .select { |f| ['', ' '].member?(f.indicator2) }
-                .select { |f| has_subfield6_value(f, /^775/) }
-                .select { |f| f.any? { |sf| sf.code == 'i' } }
-                .map do |field|
-        get_other_edition_value(field)
-      end
-      acc
-    end
-
-    def get_contained_in_display(rec)
-      acc = []
-      acc += rec.fields('773').map do |field|
-        join_subfields(field, &subfield_in(%w{a g i s t}))
-      end.select(&:present?)
-      acc += get_880(rec, '773') do |sf|
-        %w{a g i s t}.member?(sf.code)
-      end
-      acc
-    end
-
-    def get_constituent_unit_display(rec)
-      acc = []
-      acc += rec.fields('774').map do |field|
-        join_subfields(field, &subfield_in(%w{i a s t}))
-      end.select(&:present?)
-      acc += get_880(rec, '774') do |sf|
-        %w{i a s t}.member?(sf.code)
-      end
-      acc
-    end
-
-    def get_has_supplement_display(rec)
-      acc = []
-      acc += rec.fields('770').map do |field|
-        join_subfields(field, &subfield_not_6_or_8)
-      end.select(&:present?)
-      acc += get_880_subfield_not_6_or_8(rec, '770')
-      acc
-    end
-
-    def get_other_format_display(rec)
-      acc = []
-      acc += rec.fields('776').map do |field|
-        join_subfields(field, &subfield_in(%w{i a s t o}))
-      end.select(&:present?)
-      acc += get_880(rec, '774') do |sf|
-        %w{i a s t o}.member?(sf.code)
-      end
-      acc
-    end
-
-    def get_isbn_display(rec)
-      acc = []
-      acc += rec.fields('020').map do |field|
-        join_subfields(field, &subfield_in(%w{a z}))
-      end.select(&:present?)
-      acc += get_880(rec, '020') do |sf|
-        %w{a z}.member?(sf.code)
-      end
-      acc
-    end
-
-    def get_issn_display(rec)
-      acc = []
-      acc += rec.fields('022').map do |field|
-        join_subfields(field, &subfield_in(%w{a z}))
-      end.select(&:present?)
-      acc += get_880(rec, '022') do |sf|
-        %w{a z}.member?(sf.code)
-      end
-      acc
-    end
-
-    def subfield_a_is_oclc(sf)
-      sf.code == 'a' && sf.value =~ /^\(OCoLC\).*/
-    end
-
-    def get_oclc_id_values(rec)
-      rec.fields('035')
-         .select { |f| f.any? { |sf| subfield_a_is_oclc(sf) } }
-         .take(1)
-         .flat_map do |field|
-        field.find_all { |sf| subfield_a_is_oclc(sf) }.map do |sf|
-          m = /^\s*\(OCoLC\)[^1-9]*([1-9][0-9]*).*$/.match(sf.value)
-          if m
-            m[1]
-          end
-        end.compact
-      end
-    end
-
-    def get_publisher_number_display(rec)
-      acc = []
-      acc += rec.fields(%w{024 028}).map do |field|
-        join_subfields(field, &subfield_not_in(%w{5 6}))
-      end.select(&:present?)
-      acc += rec.fields('880')
-                .select { |f| has_subfield6_value(f, /^(024|028)/) }
-                .map do |field|
-        join_subfields(field, &subfield_not_in(%w{5 6}))
-      end
-      acc
-    end
-
-    def get_access_restriction_display(rec)
-      rec.fields('506').map do |field|
-        join_subfields(field, &subfield_not_in(%w{5 6}))
-      end.select(&:present?)
-    end
-
-    def get_bound_with_display(rec)
-      rec.fields('501').map do |field|
-        join_subfields(field, &subfield_not_in(%w{a}))
-      end.select(&:present?)
-    end
-
-    # some logic to extract link text and link url from an 856 field
-    def linktext_and_url(field)
-      linktext_3 = join_subfields(field, &subfield_in(%w{3}))
-      linktext_zy = field.find_all(&subfield_in(%w{z})).map(&:value).first ||
-        field.find_all(&subfield_in(%w{y})).map(&:value).first || ''
-      linktext = [ linktext_3, linktext_zy ].join(' ')
-      linkurl = field.find_all(&subfield_in(%w{u})).map(&:value).first || ''
-      linkurl = linkurl.sub(' target=_blank', '')
-      [linktext, linkurl]
-    end
-
-    def words_to_remove_from_web_link
-      @words_to_remove_from_web_link ||=
-        %w(fund funds collection collections endowment
-          endowed trust and for of the memorial)
-    end
-
-    def get_web_link_display(rec)
-      rec.fields('856')
-         .select { |f| ['2', ' ', ''].member?(f.indicator2) }
-         .flat_map do |field|
-        links = []
-        linktext, linkurl = linktext_and_url(field)
-        links << {
-          linktext: linktext,
-          linkurl: linkurl
-        }
-
-        # if the link text includes words/phrases commonly used in bookplate links
-        if linktext =~ /(Funds?|Collections?( +Gifts)?|Trust|Development|Endowment.*) +Home +Page|A +Penn +Libraries +Collection +Gift/
-          # strip out some less-meaningful words to create the filename that leslie will use when creating the bookplate image
-          imagename = linktext.gsub(/- A Penn Libraries Collection Gift/i, '')
-                              .gsub(/ Home Page/i, '')
-                              .gsub(/[&.]/, '')
-                              .split(/\W+/)
-                              .select { |word| !words_to_remove_from_web_link.member?(word.downcase) }
-                              .join('')
-          # generate image URL
-          imagesource = "https://www.library.upenn.edu/sites/default/files/images/bookplates/#{imagename}.gif"
-          links << {
-            img_src: imagesource,
-            img_alt: "#{linktext.strip} Bookplate",
-            linkurl: linkurl,
-          }
-        end
-
-        links
-      end
-    end
-
-    def get_call_number_search_values(rec)
-      # some records don't have item records, only holdings. so for safety/comprehensivenss,
-      # we need to index both and take the unique values of the entire result set.
-
-      acc = []
-
-      acc += rec.fields(EnrichedMarc::TAG_HOLDING).map do |holding|
-        classification_part =
-          holding.find_all(&subfield_in([ EnrichedMarc::SUB_HOLDING_CLASSIFICATION_PART ])).map(&:value).first
-        item_part =
-          holding.find_all(&subfield_in( [EnrichedMarc::SUB_HOLDING_ITEM_PART ])).map(&:value).first
-
-        if classification_part || item_part
-          [ classification_part, item_part ].join(' ')
-        end
-      end.compact
-
-      acc += rec.fields(EnrichedMarc::TAG_ITEM).map do |item|
-        cn_type = item.find_all { |sf| sf.code == EnrichedMarc::SUB_ITEM_CALL_NUMBER_TYPE }.map(&:value).first
-
-        item.find_all { |sf| sf.code == EnrichedMarc::SUB_ITEM_CALL_NUMBER }
-            .map(&:value)
-            .select { |call_num| call_num.present? }
-            .map { |call_num| call_num }
-            .compact
-      end.flatten(1)
-
-      acc.uniq
-    end
-
-    def get_call_number_xfacet_values(rec)
-      get_call_number_search_values(rec).map do |v|
-        references(v)
-      end
-    end
-
-    def prepare_timestamps(rec)
-      most_recent_add = rec.fields(EnrichedMarc::TAG_ITEM).flat_map do |item|
-        item.find_all(&subfield_in([EnrichedMarc::SUB_ITEM_DATE_CREATED])).map do |sf|
-          begin
-            if sf.value.size == 10
-              # On 2022-05-02, this field value (as exported in enriched publishing
-              # job from Alma) began truncating time to day-level granularity. We have
-              # no guarantee that this won't switch back in the future, so for the
-              # foreseeable future we should support both representations.
-              DateTime.strptime(sf.value, '%Y-%m-%d').to_time.to_i
-            else
-              DateTime.strptime(sf.value, '%Y-%m-%d %H:%M:%S').to_time.to_i
-            end
-          rescue Exception => e
-            puts "Error parsing date string for recently added field: #{sf.value} - #{e}"
-            nil
-          end
-        end.compact
-      end.max || 0
-
-      last_update = rec.fields('005')
-                       .select { |f| f.value.present? && !f.value.start_with?('0000') }
-                       .map do |field|
-        begin
-          DateTime.iso8601(field.value).to_time.to_i
-        rescue ArgumentError => e
-          nil
-        end
-      end.compact.first
-
-      if last_update == nil || most_recent_add > last_update
-        last_update = most_recent_add
-      end
-
-      {
-        :most_recent_add => most_recent_add,
-        :last_update => last_update
-      }
-    end
-
-    def get_full_text_link_values(rec)
-      acc = rec.fields('856')
-               .select { |f| (f.indicator1 == '4') && %w{0 1}.member?(f.indicator2) }
-               .map do |field|
-        linktext, linkurl = linktext_and_url(field)
-        {
-          linktext: linktext.present? ? linktext : linkurl,
-          linkurl: linkurl
-        }
-      end
-      add_etas_full_text(rec, acc) if is_etas(rec)
-      acc
-    end
-
-    HATHI_POSTFIX = ' from HathiTrust during COVID-19'
-
-    def add_etas_full_text(rec, acc)
-      primary_oclc_id = get_oclc_id_values(rec).first
-      return unless primary_oclc_id # defensive (e.g., if hathi match based on subsequently deleted oclc id)
-      acc << {
-        linktext: 'Online access',
-        linkurl: 'http://catalog.hathitrust.org/api/volumes/oclc/' + primary_oclc_id + '.html',
-        postfix: HATHI_POSTFIX
-      }
-    end
-
-    # It's not clear whether Alma can suppress these auto-generated
-    # records (Primo instances seem to show these records!) so we filter
-    # them out here just in case
-    def is_boundwith_record(rec)
-      rec.fields('245').any? { |f|
-        title = join_subfields(f, &subfield_in(%w{a}))
-        title.include?('Host bibliographic record for boundwith')
-      }
-    end
-
-    # values for passed-in args come from Solr, not extracted directly from MARC.
-    # TODO: this code should return more data-ish values; the HTML should be moved into a render method
-    def get_offsite_display(rec, crl_id, title, author, oclc_id)
-      id = crl_id
-      html = %Q{<a href="#{"http://catalog.crl.edu/record=#{id}~S1"}">Center for Research Libraries Holdings</a>}
-
-      f260  = rec.fields('260')
-      place = f260.map { |f| join_subfields(f, &subfield_in(%w{a})) }.join(' ')
-      publisher = f260.map { |f| join_subfields(f, &subfield_in(%w{b})) }.join(' ')
-      pubdate = f260.map { |f| join_subfields(f, &subfield_in(%w{c})) }.join(' ')
-
-      atlas_params = {
-        crl_id: id,
-        title: title,
-        author: author,
-        oclc: oclc_id,
-        place: place,
-        publisher: publisher,
-        pubdate: pubdate,
-      }
-      atlas_url = "https://atlas.library.upenn.edu/cgi-bin/forms/illcrl.cgi?#{atlas_params.to_query}"
-
-      html += %Q{<a href="#{atlas_url}">Place request</a>}
-
-      f590  = rec.fields('590')
-      if f590.size > 0
-        html += '<div>'
-        f590.each do |field|
-          html += field.join(' ')
-        end
-        html += '</div>'
-      end
-      [ html ]
-    end
-
-    @@select_pub_field = lambda do |f|
-      f.tag == '260' || (f.tag == '264' && f.indicator2 == '1')
-    end
-
-    def get_ris_cy_field(rec)
-      rec.fields.select(&@@select_pub_field).flat_map do |field|
-        field.find_all(&subfield_in(['a'])).map(&:value)
-      end
-    end
-
-    def get_ris_pb_field(rec)
-      rec.fields.select(&@@select_pub_field).flat_map do |field|
-        field.find_all(&subfield_in(['b'])).map(&:value)
-      end
-    end
-
-    def get_ris_py_field(rec)
-      rec.fields.select(&@@select_pub_field).flat_map do |field|
-        field.find_all(&subfield_in(['c'])).map(&:value)
-      end
-    end
-
-    def get_ris_sn_field(rec)
-      rec.fields.select { |f| f.tag == '020' || f.tag == '022' }.flat_map do |field|
-        field.find_all(&subfield_in(['a'])).map(&:value)
-      end
-    end
-
-  end
-
-end
-# rubocop:enable all