pennmarc 0.0.1

data/lib/pennmarc/helpers/location.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module PennMARC
+  # Methods that return Library and Location values from Alma enhanced MARC fields
+  class Location < Helper
+    class << self
+      # Retrieves library location from enriched marc 'itm' or 'hld' fields, giving priority to the item location over
+      # the holdings location. Returns item's location if available. Otherwise, returns holding's location.
+      # {PennMARC::EnrichedMarc} maps enriched marc fields and subfields created during Alma publishing.
+      # @see https://developers.exlibrisgroup.com/alma/apis/docs/bibs/R0VUIC9hbG1hd3MvdjEvYmlicy97bW1zX2lkfQ==/
+      #   Alma documentation for these added fields
+      # @param [MARC::Record] record
+      # @param [Hash] location_map hash with location_code as key and location hash as value
+      # @return [Array<String>] Array of library locations retrieved from location_map
+      def library(record, location_map)
+        location(record: record, location_map: location_map, display_value: 'library')
+      end
+
+      # Retrieves the specific location from enriched marc 'itm' or 'hld' fields, giving priority to the item location
+      # over the holdings location. Returns item library location if available. Otherwise, returns holdings library
+      # location.
+      # {PennMARC::EnrichedMarc} maps enriched marc fields and subfields created during Alma publishing.
+      # @see https://developers.exlibrisgroup.com/alma/apis/docs/bibs/R0VUIC9hbG1hd3MvdjEvYmlicy97bW1zX2lkfQ==/
+      #   Alma documentation for these added fields
+      # @param [MARC::Record] record
+      # @param [Hash] location_map hash with location_code as key and location hash as value
+      # @return [Array<String>] Array of specific locations retrieved from location_map
+      def specific_location(record, location_map)
+        location(record: record, location_map: location_map, display_value: 'specific_location')
+      end
+
+      # Base method to retrieve location data from enriched marc 'itm' or 'hld' fields, giving priority to the item
+      # location over the holdings location. Returns item location if available. Otherwise, returns holdings location.
+      # {PennMARC::EnrichedMarc} maps enriched marc fields and subfields created during Alma publishing.
+      # @see https://developers.exlibrisgroup.com/alma/apis/docs/bibs/R0VUIC9hbG1hd3MvdjEvYmlicy97bW1zX2lkfQ==/
+      #   Alma documentation for these added fields
+      # @param [MARC::Record] record
+      # @param [Hash] location_map hash with location_code as key and location hash as value
+      # @param [Symbol | String] display_value field in location hash to retrieve
+      # @return [Array<String>]
+      def location(record:, location_map:, display_value:)
+        # get enriched marc location tag and subfield code
+        location_tag_and_subfield_code(record) => {tag:, subfield_code:}
+
+        locations = record.fields(tag).flat_map do |field|
+          field.filter_map do |subfield|
+            # skip unless subfield code does not match enriched marc tag subfield code
+            next unless subfield.code == subfield_code
+
+            # skip if subfield value is 'web'
+            # 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.
+            next if subfield.value == 'web'
+
+            # skip unless subfield value is a key in location_map
+            # 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
+            next unless location_map.key?(subfield.value.to_sym)
+
+            location_map[subfield.value.to_sym][display_value.to_sym]
+          end.flatten.compact_blank
+        end.uniq
+        locations << 'Online library' if record.fields(PennMARC::EnrichedMarc::TAG_ELECTRONIC_INVENTORY).any?
+        locations
+      end
+
+      private
+
+      # Determine enriched marc location tag ('itm' or 'hld') and subfield code, giving priority to using 'itm' tag and
+      # subfield.
+      # @param [MARC::Record]
+      # @return [Hash<String, String>] containing location tag and subfield code
+      # - `:tag` (String): The enriched marc location tag
+      # - `:subfield_code` (String): The relevant subfield code
+      def location_tag_and_subfield_code(record)
+        # 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 = PennMARC::EnrichedMarc::TAG_HOLDING
+        subfield_code = PennMARC::EnrichedMarc::SUB_HOLDING_SHELVING_LOCATION
+
+        if record.fields(PennMARC::EnrichedMarc::TAG_ITEM).any?
+          tag = PennMARC::EnrichedMarc::TAG_ITEM
+          subfield_code = PennMARC::EnrichedMarc::SUB_ITEM_CURRENT_LOCATION
+        end
+
+        { tag: tag, subfield_code: subfield_code }
+      end
+    end
+  end
+end

data/lib/pennmarc/helpers/note.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module PennMARC
+  # Extracts notes from {https://www.oclc.org/bibformats/en/5xx.html 5xx} fields (mostly).
+  class Note < Helper
+    class << self
+      # Retrieve notes for display from fields {https://www.oclc.org/bibformats/en/5xx/500.html 500},
+      # {https://www.oclc.org/bibformats/en/5xx/502.html 502}, {https://www.oclc.org/bibformats/en/5xx/504.html 504},
+      # {https://www.oclc.org/bibformats/en/5xx/515.html 515}, {https://www.oclc.org/bibformats/en/5xx/518.html 518}
+      # {https://www.oclc.org/bibformats/en/5xx/525.html 525}, {https://www.oclc.org/bibformats/en/5xx/533.html 533},
+      # {https://www.oclc.org/bibformats/en/5xx/550.html 550}, {https://www.oclc.org/bibformats/en/5xx/580.html 580},
+      # {https://www.oclc.org/bibformats/en/5xx/586.html 586}, {https://www.oclc.org/bibformats/en/5xx/588.html 588},
+      # and their linked alternates.
+      # @todo legacy implementation used conditional to separate join logic for 588 field. However, this doesn't seem
+      #   necessary because 588 only has subfields 'a', '5', '6', and '8'. Do we need to look into this?
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def notes_show(record)
+        notes_fields = %w[500 502 504 515 518 525 533 550 580 586 588]
+        record.fields(notes_fields + ['880']).filter_map do |field|
+          next if field.tag == '880' && subfield_value_not_in?(field, '6', notes_fields)
+
+          join_subfields(field, &subfield_not_in?(%w[5 6 8]))
+        end
+      end
+
+      # Retrieve local notes for display from fields {https://www.oclc.org/bibformats/en/5xx/561.html 561},
+      # {https://www.oclc.org/bibformats/en/5xx/562.html 562}, {https://www.oclc.org/bibformats/en/5xx/563.html 563},
+      # {https://www.oclc.org/bibformats/en/5xx/585.html 585}, {https://www.oclc.org/bibformats/en/5xx/590.html 590}.
+      # Includes linked alternates except for 561.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def local_notes_show(record)
+        local_notes = record.fields('561').filter_map do |field|
+          next unless subfield_value?(field, 'a', /^Athenaeum copy: /)
+
+          join_subfields(field, &subfield_in?(%w[a]))
+        end
+
+        additional_fields = %w[562 563 585 590]
+
+        local_notes + record.fields(additional_fields + ['880']).filter_map do |field|
+          next if field.tag == '880' && subfield_value_not_in?(field, '6', additional_fields)
+
+          join_subfields(field, &subfield_not_in?(%w[5 6 8]))
+        end
+      end
+
+      # Retrieve provenance notes for display from fields {https://www.oclc.org/bibformats/en/5xx/561.html 561} and
+      # prefixed subject field {https://www.oclc.org/bibformats/en/6xx/650.html 650} and its linked alternate.
+      # Ignores 561 fields with subfield 'a' values that begin with 'Athenaeum copy: ' and 650 fields where subfield 'a'
+      # does not have the prefix 'PRO'.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def provenance_show(record)
+        provenance_notes = record.fields(%w[561 880]).filter_map do |field|
+          next unless field.indicator1.in?(['1', '', ' '])
+
+          next unless field.indicator2.in?([' ', ''])
+
+          next if field.tag == '880' && subfield_value_not_in?(field, '6', %w[561])
+
+          next if subfield_value?(field, 'a', /^Athenaeum copy: /)
+
+          join_subfields(field, &subfield_in?(%w[a]))
+        end
+        provenance_notes + prefixed_subject_and_alternate(record, 'PRO')
+      end
+
+      # Retrieve contents notes for display from fields {https://www.oclc.org/bibformats/en/5xx/505.html 505} and
+      # its linked alternate.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def contents_show(record)
+        record.fields(%w[505 880]).filter_map do |field|
+          next if field.tag == '880' && subfield_value_not_in?(field, '6', %w[505])
+
+          join_subfields(field, &subfield_not_in?(%w[6 8])).split('--')
+        end.flatten
+      end
+
+      # Retrieve access restricted notes for display from field {https://www.oclc.org/bibformats/en/5xx/506.html 506}.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def access_restriction_show(record)
+        record.fields('506').filter_map do |field|
+          join_subfields(field, &subfield_not_in?(%w[5 6]))
+        end
+      end
+
+      # Retrieve finding aid notes for display from field {https://www.oclc.org/bibformats/en/5xx/555.html 555} and its
+      # linked alternate.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def finding_aid_show(record)
+        datafield_and_linked_alternate(record, '555')
+      end
+
+      # Retrieve participant notes for display from field {https://www.oclc.org/bibformats/en/5xx/511.html 511} and its
+      # linked alternate.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def participant_show(record)
+        datafield_and_linked_alternate(record, '511')
+      end
+
+      # Retrieve credits notes for display from field {https://www.oclc.org/bibformats/en/5xx/508.html 508} and its
+      # linked alternate.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def credits_show(record)
+        datafield_and_linked_alternate(record, '508')
+      end
+
+      # Retrieve biography notes for display from field {https://www.oclc.org/bibformats/en/5xx/545.html 545} and its
+      # linked alternate.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def biography_show(record)
+        datafield_and_linked_alternate(record, '545')
+      end
+
+      # Retrieve summary notes for display from field {https://www.oclc.org/bibformats/en/5xx/520.html 520} and its
+      # linked alternate.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def summary_show(record)
+        datafield_and_linked_alternate(record, '520')
+      end
+    end
+  end
+end

data/lib/pennmarc/helpers/production.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module PennMARC
+  # Extracts data related to a resource's production, distribution, manufacture, and publication.
+  class Production < Helper
+    class << self
+      # Retrieve production values for display from {https://www.oclc.org/bibformats/en/2xx/264.html 264 field}.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def show(record)
+        get_264_or_880_fields(record, '0')
+      end
+
+      # Retrieve distribution values for display from {https://www.oclc.org/bibformats/en/2xx/264.html 264 field}.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def distribution_show(record)
+        get_264_or_880_fields(record, '2')
+      end
+
+      # Retrieve manufacture values for display from {https://www.oclc.org/bibformats/en/2xx/264.html 264 field}.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def manufacture_show(record)
+        get_264_or_880_fields(record, '3')
+      end
+
+      # Retrieve publication values. Return publication values from
+      # {https://www.oclc.org/bibformats/en/2xx/264.html 264 field} only if none found
+      # {https://www.oclc.org/bibformats/en/2xx/260.html 260}-262 fields.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def publication_values(record)
+        # first get inclusive dates
+        values = record.fields('245').first(1).flat_map { |field| subfield_values(field, 'f') }
+        added_2xx = record.fields(%w[260 261 262])
+                          .first(1)
+                          .map do |field|
+          join_subfields(field, &subfield_not_in?(['6'])).squish
+        end
+
+        if added_2xx.present?
+          values += added_2xx
+        else
+          fields264 = record.fields('264')
+
+          pub_place_name = fields264
+                           .find(-> { [] }) { |field| field.indicator2 == '1' }
+                           .filter_map { |sf| sf.value if sf.code.in?(%w[a b]) }
+
+          pub_date = fields264
+                     .find(-> { [] }) { |field| field.indicator2 == '1' }
+                     .filter_map { |sf| sf.value if sf.code.in?(['c']) }
+
+          copyright_date = fields264
+                           .find(-> { [] }) { |field| field.indicator2 == '4' }
+                           .filter_map { |sf| "#{pub_date.present? ? ', ' : ''}#{sf.value}" if sf.code.in?(['c']) }
+
+          joined264 = Array.wrap((pub_place_name + pub_date + copyright_date).join(' '))
+
+          values += joined264
+        end
+        values.filter_map { |value| value&.strip }
+      end
+
+      # Retrieve publication values for display from fields
+      # {https://www.oclc.org/bibformats/en/2xx/245.html 245},
+      # {https://www.oclc.org/bibformats/en/2xx/260.html 260}-262 and their linked alternates,
+      # and {https://www.oclc.org/bibformats/en/2xx/264.html 264} and its linked alternate.
+      # @param [MARC::Record] record
+      # @return [Object]
+      def publication_show(record)
+        values = record.fields('245').first(1).flat_map { |field| subfield_values(field, 'f') }
+
+        values += record.fields(%w[260 261 262]).first(1).map do |field|
+          join_subfields(field, &subfield_not_in?(%w[6 8]))
+        end
+
+        values += record.fields('880').filter_map { |field| field if subfield_value?(field, '6', /^(260|261|262)/) }
+                        .first(1).map { |field| join_subfields(field, &subfield_not_in?(%w[6 8])) }
+
+        values += record.fields('880').filter_map do |field|
+          next unless subfield_value?(field, '6', /^245/)
+
+          join_subfields(field, &subfield_in?(['f']))
+        end
+
+        values += get_264_or_880_fields(record, '1')
+        values.compact_blank
+      end
+
+      # Retrieve place of publication for display from {https://www.oclc.org/bibformats/en/7xx/752.html 752 field} and
+      # its linked alternate.
+      # @note legacy version returns array of hash objects including data for display link
+      # @param [MARC::Record] record
+      # @return [Object]
+      def place_of_publication_show(record)
+        record.fields(%w[752 880]).filter_map do |field|
+          next if field.tag == '880' && subfield_values(field, '6').exclude?('752')
+
+          place = join_subfields(field, &subfield_not_in?(%w[6 8 e w]))
+          place_extra = join_subfields(field, &subfield_in?(%w[e w]))
+          "#{place} #{place_extra}"
+        end
+      end
+
+      private
+
+      # base method to retrieve production values from {https://www.oclc.org/bibformats/en/2xx/264.html 264 field} based
+      # on indicator2.
+      # distribution and manufacture share the same logic except for indicator2
+      # @param [MARC::Record] record
+      # @param [String] indicator2
+      # @return [Array<String>]
+      def get_264_or_880_fields(record, indicator2)
+        values = record.fields('264').filter_map do |field|
+          next unless field.indicator2 == indicator2
+
+          join_subfields(field, &subfield_in?(%w[a b c]))
+        end
+        values + record.fields('880').filter_map do |field|
+          next unless field.indicator2 == indicator2
+
+          next unless subfield_value?(field, '6', /^264/)
+
+          join_subfields(field, &subfield_in?(%w[a b c]))
+        end
+      end
+    end
+  end
+end

data/lib/pennmarc/helpers/relation.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module PennMARC
+  # These MARC parsing method are grouped in virtue of their role as describing the relationship of a record to other
+  # records.
+  class Relation < Helper
+    class << self
+      CHRONOLOGY_PREFIX = 'CHR'
+
+      RELATED_WORK_FIELDS = %w[700 710 711 730].freeze
+      CONTAINS_FIELDS = %w[700 710 711 730 740].freeze
+
+      # Get values for "{https://www.oclc.org/bibformats/en/7xx/773.html Host Item}" for this record. Values contained
+      # in this field should be sufficient to locate host item record.
+      #
+      # @param [MARC::Record] record
+      # @return [Array] contained in values for display
+      def contained_in_show(record)
+        record.fields('773').map do |field|
+          join_subfields(field, &subfield_not_in?(%w[6 7 8 w]))
+        end
+      end
+
+      # Get "chronology" information from specially-prefixed 650 (subject) fields
+      # @todo why do we stuff chronology data in a 650 field?
+      # @param [MARC::Record] record
+      # @return [Array] array of chronology values
+      def chronology_show(record)
+        prefixed_subject_and_alternate(record, CHRONOLOGY_PREFIX)
+      end
+
+      # Get notes for Related Collections from {https://www.oclc.org/bibformats/en/5xx/544.html MARC 544}.
+      # @param [MARC::Record] record
+      # @return [Array]
+      def related_collections_show(record)
+        datafield_and_linked_alternate(record, '544')
+      end
+
+      # Get notes for "Publication About" from {https://www.oclc.org/bibformats/en/5xx/581.html MARC 581}.
+      # @param [MARC::Record] record
+      # @return [Array]
+      def publications_about_show(record)
+        datafield_and_linked_alternate(record, '581')
+      end
+
+      # Get related work from {RELATED_WORK_FIELDS} in the 7XX range. Require presence of sf t (title) and absence of
+      # an indicator2 value. Prefix returned values with sf i value. Also map relator codes found in sf 4. Ignore sf 0.
+      # @param [MARC::Record] record
+      # @param [Hash] relator_map
+      # @return [Array]
+      def related_work_show(record, relator_map)
+        values = record.fields(RELATED_WORK_FIELDS).filter_map do |field|
+          next unless field.indicator2.blank?
+
+          next unless subfield_defined?(field, 't')
+
+          values_with_title_prefix(field, sf_exclude: %w[0 4 6 8 i], relator_map: relator_map)
+        end
+        values + record.fields('880').filter_map do |field|
+          next unless field.indicator2.blank?
+
+          next unless subfield_value?(field, '6', /^(#{RELATED_WORK_FIELDS.join('|')})/)
+
+          next unless subfield_defined?(field, 't')
+
+          values_with_title_prefix(field, sf_exclude: %w[0 4 6 8 i], relator_map: relator_map)
+        end
+      end
+
+      # Get "Contains" values from {CONTAINS_FIELDS} in the 7XX range. Must have indicator 2 value of 2 indicating an
+      # "Analytical Entry" meaning that the record is contained by the matching field. Map relator codes in sf 4. Ignore
+      # values in sf 0, 5, 6, and 8.
+      # @param [MARC::Record] record
+      # @param [Hash] relator_map
+      # @return [Array]
+      def contains_show(record, relator_map)
+        acc = record.fields(CONTAINS_FIELDS).filter_map do |field|
+          next unless field.indicator2 == '2'
+
+          values_with_title_prefix(field, sf_exclude: %w[0 4 5 6 8 i], relator_map: relator_map)
+        end
+        acc + record.fields('880').filter_map do |field|
+          next unless field.indicator2 == '2'
+
+          next unless subfield_value?(field, '6', /^(#{CONTAINS_FIELDS.join('|')})/)
+
+          values_with_title_prefix(field, sf_include: %w[0 5 6 8 i])
+        end
+      end
+
+      # Get "Constituent Unit" values from {https://www.oclc.org/bibformats/en/7xx/774.html MARC 774}. Include
+      # subfield values in i, a, s and t.
+      # @param [MARC::Record] record
+      # @return [Array]
+      def constituent_unit_show(record)
+        acc = record.fields('774').filter_map do |field|
+          join_subfields(field, &subfield_in?(%w[i a s t]))
+        end
+        acc + linked_alternate(record, '774', &subfield_in?(%w[i a s t]))
+      end
+
+      # Get "Has Supplement" values from {https://www.oclc.org/bibformats/en/7xx/770.html MARC 770}. Ignore
+      # subfield values in 6 and 8.
+      # @param [MARC::Record] record
+      # @return [Array]
+      def has_supplement_show(record)
+        datafield_and_linked_alternate(record, '770')
+      end
+
+      private
+
+      # Handle common behavior when a relator field references a title in subfield i
+      # @param [MARC::DataField] field
+      # @param [Array, nil] sf_include subfields to include, optional
+      # @param [Array, nil] sf_exclude subfields to exclude, optional
+      # @param [Hash, nil] relator_map map relator in sf4 using this map, optional
+      # @return [String] extracted and processed values from field
+      def values_with_title_prefix(field, sf_include: nil, sf_exclude: nil, relator_map: nil)
+        raise ArgumentError('Define only sf_include or sf_exclude.') if sf_include.present? && sf_exclude.present?
+
+        subi = remove_paren_value_from_subfield_i(field) || ''
+        relator = translate_relator(subfield_values(field, '4').first, relator_map) if relator_map.present?
+        contains = if sf_include.present?
+                     join_subfields(field, &subfield_not_in?(sf_include))
+                   elsif sf_exclude.present?
+                     join_subfields(field, &subfield_not_in?(sf_exclude))
+                   end
+        [
+          subi,
+          [contains, relator].compact_blank.join(', ')
+        ].compact_blank.join(': ')
+      end
+    end
+  end
+end

data/lib/pennmarc/helpers/series.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module PennMARC
+  # Do Series-y stuff
+  class Series < Helper
+    class << self
+      def show(record)
+        acc = []
+
+        tags_present = series_tags.select { |tag| record[tag].present? }
+
+        if %w[800 810 811 400 410 411].member?(tags_present.first)
+          record.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)
+          record.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
+
+        record.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
+
+        record.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 values(record)
+        acc = []
+        added_8xx = false
+        record.fields(%w[800 810 811 830]).take(1).each do |field|
+          acc << get_series_8xx_field(field)
+          added_8xx = true
+        end
+        unless added_8xx
+          record.fields(%w[400 410 411 440 490]).take(1).map do |field|
+            acc << get_series_4xx_field(field)
+          end
+        end
+        acc
+      end
+
+      def search(record)
+        acc += record.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 += record.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 += record.fields(%w[440])
+                     .map do |field|
+          join_subfields(field, &subfield_not_in(%w[0 5 6 8 w]))
+        end
+        acc += record.fields(%w[800 810 811])
+                     .map do |field|
+          join_subfields(field, &subfield_not_in(%w[0 4 5 6 7 8 w]))
+        end
+        acc += record do |field|
+          join_subfields(field, &subfield_not_in(%w[0 5 6 7 8 w]))
+        end
+        acc + record.fields(%w[533])
+                    .map do |field|
+                field.find_all { |sf| sf.code == 'f' }
+                     .map(&:value)
+                     .map { |v| v.gsub(/\(|\)/, '') }
+                     .join(' ')
+              end
+      end
+
+      def get_continues_display(record)
+        get_continues(record, '780')
+      end
+
+      def get_continued_by_display(record)
+        get_continues(record, '785')
+      end
+
+      private
+
+      # logic for 'Continues' and 'Continued By' is very similar
+      def get_continues(record, tag)
+        record.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
+    end
+  end
+end