pennmarc 0.0.2 → 1.0.1

data/lib/pennmarc/helpers/genre.rb

@@ -11,9 +11,9 @@ module PennMARC
       # @param [MARC::Record] record
       # @return [Array<String>] array of genre values for search
       def search(record)
-        record.fields('655').map do |field|
+        record.fields('655').map { |field|
           join_subfields(field, &subfield_not_in?(%w[0 2 5 c]))
-        end.uniq
+        }.uniq
       end
 
       # Genre values for display. We display Genre/Term values if they fulfill the following criteria:
@@ -29,17 +29,18 @@ module PennMARC
       # @param [MARC::Record] record
       # @return [Array<String>] array of genre values for display
       def show(record)
-        record.fields(%w[655 880]).filter_map do |field|
+        record.fields(%w[655 880]).filter_map { |field|
           next unless allowed_genre_field?(field)
 
           next if field.tag == '880' && subfield_values(field, '6').exclude?('655')
 
-          sub_with_hyphens = field.find_all(&subfield_not_in?(%w[0 2 5 6 8 c e w])).map do |sf|
-            sep = %w[a b].exclude?(sf.code) ? ' -- ' : ' '
+          subfields = %w[a b]
+          sub_with_hyphens = field.find_all(&subfield_not_in?(%w[0 2 5 6 8 c e w])).map { |sf|
+            sep = subfields.exclude?(sf.code) ? ' -- ' : ' '
             sep + sf.value
-          end.join.lstrip
+          }.join.lstrip
           "#{sub_with_hyphens} #{field.find_all(&subfield_in?(%w[e w])).join(' -- ')}".strip
-        end.uniq
+        }.uniq
       end
 
       # Genre values for faceting. We only set Genre facet values for movies (videos) and manuscripts(?)
@@ -48,15 +49,16 @@ module PennMARC
       # @param [MARC::Record] record
       # @param [Hash] location_map
       # @return [Array<String>]
-      def facet(record, location_map)
-        locations = Location.location record: record, location_map: location_map, display_value: :specific_location
+      def facet(record, location_map: Mappers.location)
+        locations = Location.location record: record, location_map: location_map,
+                                      display_value: :specific_location
         manuscript = Format.include_manuscripts?(locations)
         video = record.fields('007').any? { |field| field.value.starts_with? 'v' }
         return [] unless manuscript || video
 
-        record.fields('655').filter_map do |field|
+        record.fields('655').filter_map { |field|
           join_subfields field, &subfield_not_in?(%w[0 2 5 c])
-        end.uniq
+        }.uniq
       end
 
       private

data/lib/pennmarc/helpers/helper.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative '../enriched_marc'
+require_relative '../mappers'
 require_relative '../util'
 
 module PennMARC

data/lib/pennmarc/helpers/identifier.rb

@@ -19,13 +19,13 @@ module PennMARC
       # @param [MARC::Record] record
       # @return [Array<String>]
       def isxn_search(record)
-        record.fields(%w[020 022]).filter_map do |field|
+        record.fields(%w[020 022]).filter_map { |field|
           if field.tag == '020'
             field.filter_map { |subfield| normalize_isbn(subfield.value) if subfield_in?(%w[a z]).call(subfield) }
           else
             field.filter_map { |subfield| subfield.value if subfield_in?(%w[a l z]).call(subfield) }
           end
-        end.flatten.uniq
+        }.flatten.uniq
       end
 
       # Get ISBN values for display from the {https://www.oclc.org/bibformats/en/0xx/020.html 020 field}
@@ -37,7 +37,7 @@ module PennMARC
       def isbn_show(record)
         isbn_values = record.fields('020').filter_map do |field|
           joined_isbn = join_subfields(field, &subfield_in?(%w[a z]))
-          joined_isbn if joined_isbn.present?
+          joined_isbn.presence
         end
         isbn_values += linked_alternate(record, '020', &subfield_in?(%w[a z]))
         isbn_values
@@ -51,7 +51,7 @@ module PennMARC
       def issn_show(record)
         issn_values = record.fields('022').filter_map do |field|
           joined_issn = join_subfields(field, &subfield_in?(%w[a z]))
-          joined_issn if joined_issn.present?
+          joined_issn.presence
         end
         issn_values += linked_alternate(record, '022', &subfield_in?(%w[a z]))
         issn_values
@@ -92,21 +92,30 @@ module PennMARC
       def publisher_number_show(record)
         publisher_numbers = record.fields(%w[024 028]).filter_map do |field|
           joined_identifiers = join_subfields(field, &subfield_not_in?(%w[5 6]))
-          joined_identifiers if joined_identifiers.present?
+          joined_identifiers.presence
         end
         publisher_numbers += linked_alternate(record, %w[024 028], &subfield_not_in?(%w[5 6]))
         publisher_numbers
       end
 
       # Get publisher issued identifiers for searching of a record. Values extracted from fields
-      # {https://www.oclc.org/bibformats/en/0xx/024.html 024} and {https://www.oclc.org/bibformats/en/0xx/024.html 028}.
+      # {https://www.oclc.org/bibformats/en/0xx/024.html 024} and {https://www.oclc.org/bibformats/en/0xx/028.html 028}.
       #
       # @param [MARC::Record] record
       # @return [Array<String>]
       def publisher_number_search(record)
         record.fields(%w[024 028]).filter_map do |field|
           joined_identifiers = join_subfields(field, &subfield_in?(%w[a]))
-          joined_identifiers if joined_identifiers.present?
+          joined_identifiers.presence
+        end
+      end
+
+      # Retrieve fingerprint for display from the {https://www.oclc.org/bibformats/en/0xx/026.html 026} field
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def fingerprint_show(record)
+        record.fields('026').map do |field|
+          join_subfields(field, &subfield_not_in?(%w[2 5 6 8]))
         end
       end
 

data/lib/pennmarc/helpers/language.rb

@@ -25,12 +25,12 @@ module PennMARC
       # the 008 control field. Language facet and search values will typically be the same.
       #
       # @param [MARC::Record] record
-      # @param [Hash] mapping hash for language code translation
+      # @param [Hash] language_map hash for language code translation
       # @return [String] nice value for language
-      def search(record, mapping)
+      def search(record, language_map: Mappers.language)
         control_field = record['008']&.value
         language_code = control_field[35..37]
-        mapping[language_code.to_sym || UNDETERMINED_CODE]
+        language_map[language_code.to_sym || UNDETERMINED_CODE]
       end
     end
   end

data/lib/pennmarc/helpers/link.rb

@@ -4,6 +4,12 @@ module PennMARC
   # Do Link-y stuff
   class Link < Helper
     class << self
+      # @todo the legacy code here is a hot mess for a number of reasons, what do we need this field to do?
+      # @note port the needed parts from get_offsite_display, don't return HTML
+      # @param [MARC::Record] record
+      # @return [Object]
+      def offsite(record); end
+
       def full_text(record:); end
 
       def web(record:); end

data/lib/pennmarc/helpers/location.rb

@@ -12,7 +12,7 @@ module PennMARC
       # @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)
+      def library(record, location_map: Mappers.location)
         location(record: record, location_map: location_map, display_value: 'library')
       end
 
@@ -25,7 +25,7 @@ module PennMARC
       # @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)
+      def specific_location(record, location_map: Mappers.location)
         location(record: record, location_map: location_map, display_value: 'specific_location')
       end
 
@@ -35,15 +35,15 @@ module PennMARC
       # @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
+      # @param [Hash] location_map hash with location_code as key and location hash as value
       # @return [Array<String>]
-      def location(record:, location_map:, display_value:)
+      def location(record:, display_value:, location_map:)
         # 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|
+        locations = record.fields(tag).flat_map { |field|
+          field.filter_map { |subfield|
             # skip unless subfield code does not match enriched marc tag subfield code
             next unless subfield.code == subfield_code
 
@@ -59,8 +59,8 @@ module PennMARC
             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
+          }.flatten.compact_blank
+        }.uniq
         locations << 'Online library' if record.fields(PennMARC::EnrichedMarc::TAG_ELECTRONIC_INVENTORY).any?
         locations
       end

data/lib/pennmarc/helpers/note.rb

@@ -72,11 +72,11 @@ module PennMARC
       # @param [MARC::Record] record
       # @return [Array<String>]
       def contents_show(record)
-        record.fields(%w[505 880]).filter_map do |field|
+        record.fields(%w[505 880]).filter_map { |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
+        }.flatten
       end
 
       # Retrieve access restricted notes for display from field {https://www.oclc.org/bibformats/en/5xx/506.html 506}.
@@ -127,6 +127,56 @@ module PennMARC
       def summary_show(record)
         datafield_and_linked_alternate(record, '520')
       end
+
+      # Retrieve arrangement values for display from field field {https://www.oclc.org/bibformats/en/3xx/351.html 351}.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def arrangement_show(record)
+        datafield_and_linked_alternate(record, '351')
+      end
+
+      # Retrieve system details notes for display from fields {https://www.oclc.org/bibformats/en/5xx/538.html 538},
+      # {https://www.oclc.org/bibformats/en/3xx/344.html 344}, {https://www.oclc.org/bibformats/en/3xx/345.html 345},
+      # {https://www.oclc.org/bibformats/en/3xx/346.html 346}, {https://www.oclc.org/bibformats/en/3xx/347.html 347},
+      # and their linked alternates.
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def system_details_show(record)
+        system_details_notes = record.fields(%w[538 880]).filter_map do |field|
+          next if field.tag == '880' && subfield_value_not_in?(field, '6', ['538'])
+
+          sub3_and_other_subs(field, &subfield_in?(%w[a i u]))
+        end
+        system_details_notes += record.fields(%w[344 880]).filter_map do |field|
+          next if field.tag == '880' && subfield_value_not_in?(field, '6', ['344'])
+
+          sub3_and_other_subs(field, &subfield_in?(%w[a b c d e f g h]))
+        end
+        system_details_notes += record.fields(%w[345 346 880]).filter_map do |field|
+          next if field.tag == '880' && subfield_value_not_in?(field, '6', %w[345 346])
+
+          sub3_and_other_subs(field, &subfield_in?(%w[a b]))
+        end
+        system_details_notes += record.fields(%w[347 880]).filter_map do |field|
+          next if field.tag == '880' && subfield_value_not_in?(field, '6', ['347'])
+
+          sub3_and_other_subs(field, &subfield_in?(%w[a b c d e f]))
+        end
+        system_details_notes
+      end
+
+      private
+
+      # For system details: extract subfield ǂ3 plus other subfields as specified by passed-in block. Pays special
+      # attention to punctuation, joining subfield ǂ3 values with a colon-space (': ').
+      # @param [MARC::DataField] field
+      # @param [Proc] selector
+      # @return [String]
+      def sub3_and_other_subs(field, &)
+        sub3 = field.filter_map { |sf| trim_trailing('period', sf.value) if sf.code == '3' }.join(': ')
+        oth_subs = join_subfields(field, &)
+        [sub3, trim_trailing('semicolon', oth_subs)].join(' ')
+      end
     end
   end
 end

data/lib/pennmarc/helpers/relation.rb

@@ -48,16 +48,16 @@ module PennMARC
       # @param [MARC::Record] record
       # @param [Hash] relator_map
       # @return [Array]
-      def related_work_show(record, relator_map)
+      def related_work_show(record, relator_map: Mappers.relator)
         values = record.fields(RELATED_WORK_FIELDS).filter_map do |field|
-          next unless field.indicator2.blank?
+          next if field.indicator2.present?
 
           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 if field.indicator2.present?
 
           next unless subfield_value?(field, '6', /^(#{RELATED_WORK_FIELDS.join('|')})/)
 
@@ -73,7 +73,7 @@ module PennMARC
       # @param [MARC::Record] record
       # @param [Hash] relator_map
       # @return [Array]
-      def contains_show(record, relator_map)
+      def contains_show(record, relator_map: Mappers.relator)
         acc = record.fields(CONTAINS_FIELDS).filter_map do |field|
           next unless field.indicator2 == '2'
 

data/lib/pennmarc/helpers/series.rb

@@ -1,116 +1,202 @@
 # frozen_string_literal: true
 
 module PennMARC
-  # Do Series-y stuff
+  # Do Series and series-related field processing. Many of these fields are added entries that are justified by
+  # corresponding series statements (usually 490). These fields provide information about the published series in which
+  # a book, encoded finding aid, or other published work has appeared
+  # @todo We may want to include 410 in the display tags, since it is included in references below.
   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
+      # 800 - Series Added Entry-Personal Name - https://www.loc.gov/marc/bibliographic/bd800.html
+      # 810 - Series Added Entry-Corporate Name - https://www.loc.gov/marc/bibliographic/bd810.html
+      # 410 - Series Statement/Added Entry-Corporate Name - https://www.loc.gov/marc/bibliographic/bd410.html
+      # 811 - Series Added Entry-Meeting Name - https://www.loc.gov/marc/bibliographic/bd811.html
+      # 830 - Series Added Entry-Uniform Title - https://www.loc.gov/marc/bibliographic/bd830.html
+      # 400 - Series Statement/Added Entry-Personal Name - https://www.loc.gov/marc/bibliographic/bd400.html
+      # 411 - Series Statement/Added Entry Meeting Name - https://www.loc.gov/marc/bibliographic/bd411.html
+      # 440 - Series Statement/Added Entry-Title - https://www.loc.gov/marc/bibliographic/bd440.html
+      # 490 - Series Statement - https://www.loc.gov/marc/bibliographic/bd490.html
+      DISPLAY_TAGS = %w[800 810 811 830 400 411 440 490].freeze
 
-        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
+      # Fields for display that pertain to series information.
+      # @param [MARC::Record] record
+      # @param [Hash] relator_map
+      # @return [Array<String>] array of series information
+      def show(record, relator_map: Mappers.relator)
+        tags_present = DISPLAY_TAGS.select { |tag| record[tag].present? }
 
-        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
+        values = if %w[800 810 811 400 410 411].member?(tags_present.first)
+                   author_show_entries(record, tags_present.first, relator_map)
+                 elsif %w[830 440 490].member?(tags_present.first)
+                   title_show_entries(record, tags_present.first)
+                 end || []
 
-        acc
+        values += remaining_show_entries(record, tags_present)
+        values + series_880_fields(record)
       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
+      # Values from series fields for display.
+      # @param [MARC::Record] record
+      # @param [Hash] relator_map
+      # @return [Array<String>] array of series values
+      def values(record, relator_map: Mappers.relator)
+        series_8x = record.fields(%w[800 810 811 830]).first
+        return Array.wrap(series_field(series_8x, relator_map)) if series_8x
+
+        series_4x = record.fields(%w[400 410 411 440 490]).first
+        Array.wrap(series_field(series_4x, relator_map)) if series_4x
       end
 
+      # Series fields for search.
+      # @param [MARC::Record] record
+      # @return [Array<String>] array of series values
       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]))
+        values = record.fields(%w[400 410 411]).filter_map do |field|
+          subfields = if field.indicator2 != '0'
+                        %w[4 6 8]
+                      elsif field.indicator2 != '1'
+                        %w[4 6 8 a]
+                      else
+                        next
+                      end
+          join_subfields(field, &subfield_not_in?(subfields))
         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]))
+        values += record.fields(%w[440]).filter_map do |field|
+          join_subfields(field, &subfield_not_in?(%w[0 5 6 8 w]))
         end
-        acc += record.fields(%w[440])
-                     .map do |field|
-          join_subfields(field, &subfield_not_in(%w[0 5 6 8 w]))
+        values += record.fields(%w[800 810 811]).filter_map do |field|
+          join_subfields(field, &subfield_not_in?(%w[0 4 5 6 7 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]))
+        values += record.fields(%w[830]).filter_map do |field|
+          join_subfields(field, &subfield_not_in?(%w[0 5 6 7 8 w]))
         end
-        acc += record do |field|
-          join_subfields(field, &subfield_not_in(%w[0 5 6 7 8 w]))
+        values += record.fields(%w[533]).filter_map do |field|
+          filtered_values = field.filter_map { |sf| sf.value if sf.code == 'f' }
+          next if filtered_values.empty?
+
+          filtered_values.map { |v| v.gsub(/\(|\)/, '') }.join(' ')
         end
-        acc + record.fields(%w[533])
-                    .map do |field|
-                field.find_all { |sf| sf.code == 'f' }
-                     .map(&:value)
-                     .map { |v| v.gsub(/\(|\)/, '') }
-                     .join(' ')
-              end
+        values
       end
 
+      # Information concerning the immediate predecessor of the target item (chronological relationship). When a note
+      # is generated from this field, the introductory term or phrase may be generated based on the value in the second
+      # indicator position for display.
+      # https://www.loc.gov/marc/bibliographic/bd780.html
+      # @param [MARC::Record] record
+      # @return [String] continues fields string
       def get_continues_display(record)
-        get_continues(record, '780')
+        continues(record, '780')
       end
 
+      # Information concerning the immediate successor to the target item (chronological relationship). When a note is
+      # generated from this field, the introductory phrase may be generated based on the value in the second indicator
+      # position for display.
+      # https://www.loc.gov/marc/bibliographic/bd785.html
+      # @param [MARC::Record] record
+      # @return [String] continued by fields string
       def get_continued_by_display(record)
-        get_continues(record, '785')
+        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]))
+      # If any of these values: 800 810 811 400 410 411 are present, return a string with series information and
+      # appended values.
+      # @note added 2017/04/10: filter out 0 (authority record numbers) added by Alma
+      # @param [MARC::Record] record
+      # @param [String] first_tag
+      # @param [Hash] relator_mapping
+      # @return [Array<Hash>] array of author show entry hashes
+      def author_show_entries(record, first_tag, relator_mapping)
+        record.fields(first_tag).map do |field|
+          series = join_subfields(field, &subfield_not_in?(%w[0 5 6 8 e t w v n]))
+          author_show_subfields = %w[e w v n t]
+          pairs = field.map do |sf|
+            if author_show_subfields.member?(sf.code)
+              [' ', sf.value]
+            elsif sf.code == '4'
+              [', ', translate_relator(sf.value, relator_mapping)]
+            end
+          end
+          series_append = pairs.flatten.join.strip
+          "#{series} #{series_append}".squish
+        end || []
+      end
+
+      # If any of these values: 830 440 490 are present, return a string with series information and appended values.
+      # @note added 2017/04/10: filter out 0 (authority record numbers) added by Alma
+      # @param [MARC::Record] record
+      # @param [String] first_tag
+      # @return [Array<Hash>] array of author show entry hashes
+      def title_show_entries(record, first_tag)
+        record.fields(first_tag).map do |field|
+          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]))
+          "#{series} #{series_append}".squish
+        end || []
+      end
+
+      # Assemble an array of hashes that includes the remaining show entries.
+      # @note added 2017/04/10: filter out 0 (authority record numbers) added by Alma
+      # @param [MARC::Record] record
+      # @param [Array<String>] tags_present
+      # @return [Array<Hash>] array of remaining show entry hashes
+      def remaining_show_entries(record, tags_present)
+        record.fields(tags_present.drop(1)).map do |field|
+          join_subfields(field, &subfield_not_in?(%w[0 5 6 8]))
+        end || []
+      end
+
+      # TODO: use linked alternate in place of this function
+      # @note There are multiple locations in these helpers where we should be able to use the linked_alternate util.
+      # @note This requires a more comprehensive evaluation and refactor of the linked_alternate utility.
+      #
+      # Fully content-designated representation, in a different script, of another field in the same record. Field 880
+      # is linked to the associated regular field by subfield $6 (Linkage). A subfield $6 in the associated field also
+      # links that field to the 880 field. The data in field 880 may be in more than one script. This function exists
+      # because it differs than the tradition use of linked_alternate.
+      # @param [MARC::Record] record
+      def series_880_fields(record)
+        record.fields('880').filter_map do |field|
+          next unless subfield_value?(field, '6', /^(800|810|811|830|400|410|411|440|490)/)
+
+          join_subfields(field, &subfield_not_in?(%w[5 6 8]))
+        end || []
+      end
+
+      # Assemble a formatted string of a given field.
+      # @note added 2017/04/10: filter out 0 (authority record numbers) added by Alma
+      # @param [MARC::Field] field
+      # @param [Hash] relator_mapping
+      # @return [String] series 4xx field
+      def series_field(field, relator_mapping)
+        subfields = if field.tag.start_with? '4'
+                      %w[0 4 6 8]
+                    else
+                      %w[0 4 5 6 8]
+                    end
+        s = field.filter_map { |sf|
+          if subfields.exclude?(sf.code)
+            " #{sf.value}"
+          elsif sf.code == '4'
+            ", #{translate_relator(sf.value, relator_mapping)}"
+          end
+        }.join
+        s2 = s + (%w[. -].exclude?(s[-1]) ? '.' : '')
+        s2.squish
+      end
+
+      # Get subfields from a given field (continues or continued_by).
+      # @param [MARC::Record] record
+      # @param [String] tag
+      # @return [String] joined subfields
+      def continues(record, tag)
+        record.fields.filter_map do |field|
+          next unless field.tag == tag || (field.tag == '880' && subfield_value?(field, '6', /^#{tag}/))
+          next unless field.any?(&subfield_in?(%w[i a s t n d]))
+
+          join_subfields(field, &subfield_in?(%w[i a s t n d]))
         end
       end
     end