pennmarc 0.0.1

data/lib/pennmarc/helpers/edition.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module PennMARC
+  # Do Edition-y stuff
+  class Edition < Helper
+    class << self
+      # Edition values for display on a record page. Field 250 is information relating to the edition of a work as
+      # determined by applicable cataloging rules. For mixed materials, field 250 is used to record statements relating
+      # to collections that contain versions of works existing in two or more versions (or states) in single or multiple
+      # copies (e.g., different drafts of a film script). For continuing resources, this field is not used for
+      # sequential edition statements such as 1st- ed. This type of information is contained in field 362 (Dates of
+      # Publication and/or Volume Designation).
+      # https://www.loc.gov/marc/bibliographic/bd250.html
+      # @param [MARC::Record] record
+      # @return [Array<String>] array of editions and their alternates
+      def show(record)
+        record.fields('250').map do |field|
+          join_subfields(field, &subfield_not_in?(%w[6 8]))
+        end + linked_alternate_not_6_or_8(record, '250')
+      end
+
+      # Edition values for display in search results. Just grab the first 250 field.
+      # @param [MARC::Record] record
+      # @return [String, NilClass] string of all first 250 subfields, excluding 6 and 8
+      def values(record)
+        edition = record.fields('250').first
+        return unless edition.present?
+
+        join_subfields(edition, &subfield_not_in?(%w[6 8]))
+      end
+
+      # Entry for another available edition of the target item (horizontal relationship). When a note is generated
+      # from this field, the introductory phrase Other editions available: may be generated based on the field tag for
+      # display.
+      # https://www.loc.gov/marc/bibliographic/bd775.html
+      # @param [MARC::Record] record
+      # @return [Array<String>] array of other edition strings
+      def other_show(record, relator_mapping)
+        record.fields('775').filter_map do |field|
+          next unless subfield_defined?(field, :i)
+
+          other_edition_value(field, relator_mapping)
+        end + record.fields('880').filter_map do |field|
+          next unless field.indicator2.blank? && subfield_value_in?(field, '6', %w[775]) &&
+                      subfield_defined?(field, 'i')
+
+          other_edition_value(field, relator_mapping)
+        end
+      end
+
+      private
+
+      # Assemble a string of relevant edition information.
+      # @param [MARC::DataField] field
+      # @param [Hash] relator_mapping
+      # @return [String (frozen)] assembled other version string
+      def other_edition_value(field, relator_mapping)
+        subi = remove_paren_value_from_subfield_i(field) || ''
+        other_editions = field.filter_map do |sf|
+          next if %w[6 8].member?(sf.code)
+
+          if %w[s x z].member?(sf.code)
+            " #{sf.value}"
+          elsif sf.code == 't'
+            relator = translate_relator(sf.value, relator_mapping)
+            next if relator.blank?
+
+            " #{relator}. "
+          end
+        end.join
+        other_editions_append = field.filter_map do |sf|
+          next if %w[6 8].member?(sf.code)
+
+          if %w[i h s t x z e f o r w y 7].exclude?(sf.code)
+            " #{sf.value}"
+          elsif sf.code == 'h'
+            " (#{sf.value}) "
+          end
+        end.join
+        prepend = trim_trailing(:period, subi).squish
+
+        if other_editions.present? || other_editions_append.present?
+          "#{prepend}: #{other_editions} #{other_editions_append}".squish
+        else
+          prepend
+        end
+      end
+    end
+  end
+end

data/lib/pennmarc/helpers/format.rb

@@ -0,0 +1,312 @@
+# frozen_string_literal: true
+
+module PennMARC
+  # Handle parsing out "Format" and "Other Format" values. Special care goes into controlling the format values for
+  # faceting.
+  class Format < Helper
+    class << self
+      # These constants represent the set of desired Format values for faceting.
+      ARCHIVE = 'Archive'
+      BOOK = 'Book'
+      CONFERENCE_EVENT = 'Conference/Event'
+      DATAFILE = 'Datafile'
+      GOVDOC = 'Government document'
+      IMAGE = 'Image'
+      JOURNAL_PERIODICAL = 'Journal/Periodical'
+      MANUSCRIPT = 'Manuscript'
+      MAP_ATLAS = 'Map/Atlas'
+      MICROFORMAT = 'Microformat'
+      MUSICAL_SCORE = 'Musical score'
+      NEWSPAPER = 'Newspaper'
+      OTHER = 'Other'
+      PROJECTED_GRAPHIC = 'Projected graphic'
+      SOUND_RECORDING = 'Sound recording'
+      THESIS_DISSERTATION = 'Thesis/Dissertation'
+      THREE_D_OBJECT = '3D object'
+      VIDEO = 'Video'
+      WEBSITE_DATABASE = 'Website/Database'
+
+      # Get any Format values from {https://www.oclc.org/bibformats/en/3xx/300.html 300},
+      # 254, 255, 310, 342, 352 or {https://www.oclc.org/bibformats/en/3xx/340.html 340} field. based on the source
+      # field, different subfields are used.
+      # @note ported from get_format_display
+      # @param [MARC::Record] record
+      # @return [Array<String>] format values for display
+      def show(record)
+        results = record.fields('300').map { |f| join_subfields(f, &subfield_not_in?(%w[3 6 8])) }
+        results += record.fields(%w[254 255 310 342 352 362]).map do |f|
+          join_subfields(f, &subfield_not_in?(%w[6 8]))
+        end
+        results += record.fields('340').map { |f| join_subfields(f, &subfield_not_in?(%w[0 2 6 8])) }
+        results += record.fields('880').map do |f|
+          subfield_to_ignore = if subfield_value?(f, 6, /^300/)
+                                 %w[3 6 8]
+                               elsif subfield_value?(f, 6, /^(254|255|310|342|352|362)/)
+                                 %w[6 8]
+                               elsif subfield_value?(f, 6, /^340/)
+                                 %w[0 2 6 8]
+                               end
+          join_subfields(f, &subfield_not_in?(subfield_to_ignore))
+        end
+        results.compact_blank
+      end
+
+      # Get Format values for faceting. Format values are determined using complex logic for each possible format value.
+      # The primary fields considered in determining Format facet values are:
+      #
+      # 1. "Type of Record" and "Bibliographic level" values extracted from the
+      #    {https://www.loc.gov/marc/bibliographic/bdleader.html MARC leader}.
+      # 2. Location name values and "Classification part" from Alma "enhanced" MARC holding/item information
+      # 3. {https://www.loc.gov/marc/bibliographic/bd007.html 007} values, the first
+      #    {https://www.loc.gov/marc/bibliographic/bd008.html 008} value, and the first character form all
+      #    {https://www.loc.gov/marc/bibliographic/bd006.html 006} values (form)
+      # 4. Medium values from {https://www.oclc.org/bibformats/en/2xx/245.html#subfieldh 245 ǂh}
+      # 5. Media Type values from {https://www.oclc.org/bibformats/en/3xx/337.html#subfielda 337 ǂa}
+      # Additional fields are considered for many of the formats. Much of this logic has been moved to private methods
+      # to keep this method from becoming too unwieldy.
+      # @todo is the conditional structure here still best practice? see the "Thesis on Microfilm" case in the specs
+      #       for this helper method
+      # @note ported from get_format
+      # @param [MARC::Record] record
+      # @param [Hash] location_map
+      # @return [Array<String>] format values for faceting
+
+      def facet(record, location_map)
+        formats = []
+        format_code = leader_format(record.leader)
+        f007 = record.fields('007').map(&:value)
+        f008 = record.fields('008').first&.value || ''
+        f006_forms = record.fields('006').map { |field| field.value[0] }
+        title_medium = subfield_values_for tag: '245', subfield: :h, record: record
+        media_type = subfield_values_for tag: '337', subfield: :a, record: record
+
+        # Get Call Number for holdings - ǂh gives us the 'Classification part' which can contain strings like
+        # 'Microfilm'
+        call_nums = record.fields(EnrichedMarc::TAG_HOLDING).map do |field|
+          join_subfields(field, &subfield_in?([EnrichedMarc::SUB_HOLDING_CLASSIFICATION_PART,
+                                               EnrichedMarc::SUB_HOLDING_ITEM_PART]))
+        end
+
+        # get all specific_location values from inventory info
+        locations = Location.location record: record, location_map: location_map, display_value: :specific_location
+
+        if include_manuscripts?(locations)
+          formats << MANUSCRIPT
+        elsif archives_but_not_cajs_or_nursing?(locations)
+          formats << ARCHIVE
+        elsif micro_or_microform?(call_nums, locations, media_type, title_medium)
+          formats << MICROFORMAT
+        else
+          # any of these
+          formats << THESIS_DISSERTATION if thesis_or_dissertation?(format_code, record)
+          formats << CONFERENCE_EVENT if conference_event?(record)
+          formats << NEWSPAPER if newspaper?(f008, format_code)
+          formats << GOVDOC if government_document?(f008, record, format_code)
+
+          # but only one of these
+          formats << if website_database?(f006_forms, format_code)
+                       WEBSITE_DATABASE
+                     elsif book?(format_code, title_medium, record)
+                       BOOK
+                     elsif musical_score?(format_code)
+                       MUSICAL_SCORE
+                     elsif map_atlas?(format_code)
+                       MAP_ATLAS
+                     elsif graphical_media?(format_code)
+                       graphical_media_type(f007)
+                     elsif sound_recording?(format_code)
+                       SOUND_RECORDING
+                     elsif image?(format_code)
+                       IMAGE
+                     elsif datafile?(format_code)
+                       DATAFILE
+                     elsif journal_periodical?(format_code)
+                       JOURNAL_PERIODICAL
+                     elsif three_d_object?(format_code)
+                       THREE_D_OBJECT
+                     else
+                       OTHER
+                     end
+        end
+        formats.concat(curated_format(record))
+      end
+
+      # Show "Other Format" values from {https://www.oclc.org/bibformats/en/7xx/776.html 776} and any 880 linkage.
+      # @todo is 774 an error in the linked field in legacy? i changed to 776 here
+      # @param [MARC::Record] record
+      # @return [Array] other format values for display
+      def other_show(record)
+        other_formats = record.fields('776').filter_map do |field|
+          value = join_subfields(field, &subfield_in?(%w[i a s t o]))
+          next if value.blank?
+
+          value
+        end
+        other_formats + linked_alternate(record, '776') do |sf|
+          sf.code.in? %w[i a s t o]
+        end
+      end
+
+      # Check if a set of locations has any locations that include the term 'manuscripts'
+      # @param [Array<String>] locations
+      # @return [Boolean]
+      def include_manuscripts?(locations)
+        locations.any? { |loc| loc =~ /manuscripts/i }
+      end
+
+      private
+
+      # Get 'Curated' format from.
+      # {https://upennlibrary.atlassian.net/wiki/spaces/ALMA/pages/323912493/Local+9XX+Field+Use+in+Alma local field
+      # 944} ǂa, as long as it is not a numerical value.
+      # @param [MARC::Record] record
+      # @return [Array]
+      def curated_format(record)
+        record.fields('944').filter_map do |field|
+          subfield_a = field.find { |sf| sf.code == 'a' }
+          next if subfield_a.nil? || (subfield_a.value == subfield_a.value.to_i.to_s)
+
+          subfield_a.value
+        end.uniq
+      end
+
+      # @param [String] format_code
+      # @return [Boolean]
+      def image?(format_code)
+        format_code.in?(%w[km kd])
+      end
+
+      # @param [String] format_code
+      # @return [Boolean]
+      def datafile?(format_code)
+        format_code == 'mm'
+      end
+
+      # @param [String] format_code
+      # @return [Boolean]
+      def journal_periodical?(format_code)
+        format_code.in?(%w[as gs])
+      end
+
+      # @param [String] format_code
+      # @return [Boolean]
+      def three_d_object?(format_code)
+        format_code.start_with?('r')
+      end
+
+      # @param [String] format_code
+      # @return [Boolean]
+      def sound_recording?(format_code)
+        format_code.in?(%w[im jm jc jd js])
+      end
+
+      # @param [String] format_code
+      # @return [Boolean]
+      def graphical_media?(format_code)
+        format_code == 'gm'
+      end
+
+      # @param [String] format_code
+      # @return [Boolean]
+      def map_atlas?(format_code)
+        format_code&.start_with?('e') || format_code == 'fm'
+      end
+
+      # @param [String] format_code
+      # @return [Boolean]
+      def musical_score?(format_code)
+        format_code.in?(%w[ca cb cd cm cs dm])
+      end
+
+      # @param [String] format_code
+      # @param [Array<String>] title_medium
+      # @param [MARC::Record] record
+      # @return [Boolean]
+      def book?(format_code, title_medium, record)
+        title_forms = subfield_values_for tag: '245', subfield: :k, record: record
+        format_code.in?(%w[aa ac am tm]) &&
+          title_forms.none? { |v| v =~ /kit/i } &&
+          title_medium.none? { |v| v =~ /micro/i }
+      end
+
+      # @param [Array<String>] f006_forms
+      # @param [String] format_code
+      # @return [Boolean]
+      def website_database?(f006_forms, format_code)
+        format_code&.end_with?('i') ||
+          (format_code == 'am' && f006_forms.include?('m') && f006_forms.include?('s'))
+      end
+
+      # @param [String] f008
+      # @param [MARC::Record] record
+      # @param [String] format_code
+      # @return [Boolean]
+      def government_document?(f008, record, format_code)
+        # is a 260 entry present, and does it have a b that matches 'press'
+        f260press = record.fields('260').any? do |field|
+          field.select { |sf| sf.code == 'b' && sf.value =~ /press/i }.any?
+        end
+        %w[c d i j].exclude?(format_code[0]) && f008[28].in?(%w[f i o]) && !f260press
+      end
+
+      # @param [String] f008
+      # @param [String] format_code
+      # @return [Boolean]
+      def newspaper?(f008, format_code)
+        format_code == 'as' && (f008[21] == 'n' || f008[22] == 'e')
+      end
+
+      # @param [MARC::Record] record
+      # @return [Boolean]
+      def conference_event?(record)
+        record.fields('111').any? || record.fields('711').any? # TODO: use field_present helper here and below?
+      end
+
+      # @param [MARC::Record] record
+      # @param [String] format_code
+      # @return [Boolean]
+      def thesis_or_dissertation?(format_code, record)
+        record.fields('502').any? && format_code == 'tm'
+      end
+
+      # @param [Array<String>] title_medium
+      # @param [Array<String>] media_type
+      # @param [Array<String>] locations
+      # @param [Array<String>] call_nums
+      # @return [Boolean]
+      def micro_or_microform?(call_nums, locations, media_type, title_medium)
+        locations.any? { |loc| loc =~ /micro/i } ||
+          title_medium.any? { |val| val =~ /micro/i } ||
+          call_nums.any? { |val| val =~ /micro/i } ||
+          media_type.any? { |val| val =~ /microform/i }
+      end
+
+      # @todo "cajs" has no match in our location map, so it is not doing anything. Does this intend to catch cjsambx
+      #       "Library at the Katz Center - Archives"?
+      # @param [Array<String>] locations
+      # @return [Boolean]
+      def archives_but_not_cajs_or_nursing?(locations)
+        locations.any? { |loc| loc =~ /archives/i } &&
+          locations.none? { |loc| loc =~ /cajs/i } &&
+          locations.none? { |loc| loc =~ /nursing/i }
+      end
+
+      # Consider {https://www.loc.gov/marc/bibliographic/bd007g.html 007} to determine graphical media format
+      # @param [Array<String>] f007
+      # @return [String (frozen)]
+      def graphical_media_type(f007)
+        if f007.any? { |v| v.start_with?('g') }
+          PROJECTED_GRAPHIC
+        else
+          VIDEO
+        end
+      end
+
+      # @param [String] leader
+      # @return [String]
+      def leader_format(leader)
+        leader[6..7] || '  '
+      end
+    end
+  end
+end

data/lib/pennmarc/helpers/genre.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module PennMARC
+  # Genre field values come from the {https://www.oclc.org/bibformats/en/6xx/655.html 655}, but for some
+  # contexts we are only interested in a subset of the declared terms in a record.
+  class Genre < Helper
+    class << self
+      # Genre values for searching. We're less picky about what is included here to enable discovery via any included
+      # 655 data.
+      #
+      # @param [MARC::Record] record
+      # @return [Array<String>] array of genre values for search
+      def search(record)
+        record.fields('655').map do |field|
+          join_subfields(field, &subfield_not_in?(%w[0 2 5 c]))
+        end.uniq
+      end
+
+      # Genre values for display. We display Genre/Term values if they fulfill the following criteria:
+      #  - The field is in {https://www.oclc.org/bibformats/en/6xx/655.html MARC 655}. Or the field is in MARC 880 with
+      #    subfield 6 including '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.
+      # @todo subfields e and w do not appear in the documentation for 655, but we give them special consideration here,
+      #       what gives?
+      # @note legacy method returns a link object
+      # @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|
+          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) ? ' -- ' : ' '
+            sep + sf.value
+          end.join.lstrip
+          "#{sub_with_hyphens} #{field.find_all(&subfield_in?(%w[e w])).join(' -- ')}".strip
+        end.uniq
+      end
+
+      # Genre values for faceting. We only set Genre facet values for movies (videos) and manuscripts(?)
+      # @todo the Genre facet in Franklin is pretty ugly. It could be cleaned up by limiting the subfields included
+      #       here and cleaning up punctuation.
+      # @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
+        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|
+          join_subfields field, &subfield_not_in?(%w[0 2 5 c])
+        end.uniq
+      end
+
+      private
+
+      # @param [MARC::DataField] field
+      # @return [TrueClass, FalseClass]
+      def allowed_genre_field?(field)
+        field.indicator2.in?(%w[0 4]) || subfield_value_in?(field, '2', PennMARC::HeadingControl::ALLOWED_SOURCE_CODES)
+      end
+    end
+  end
+end

data/lib/pennmarc/helpers/helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative '../enriched_marc'
+require_relative '../util'
+
+module PennMARC
+  # Shared helper code
+  class Helper
+    extend Util
+  end
+end

data/lib/pennmarc/helpers/identifier.rb

@@ -0,0 +1,134 @@
+# frozen_string_literal: true
+
+module PennMARC
+  # Parser methods for extracting identifier values.
+  class Identifier < Helper
+    class << self
+      # Get Alma MMS ID value
+      #
+      # @param [MARC::Record] record
+      # @return [String]
+      def mmsid(record)
+        record.fields('001').first.value
+      end
+
+      # Get normalized ISXN values for searching of a record. Values aggregated from subfield 'a' and 'z' of the
+      # {https://www.oclc.org/bibformats/en/0xx/020.html 020 field}, and subfield 'a', 'l', and 'z' of the
+      # the {https://www.oclc.org/bibformats/en/0xx/020.html 022 field}.
+      #
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def isxn_search(record)
+        record.fields(%w[020 022]).filter_map do |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
+      end
+
+      # Get ISBN values for display from the {https://www.oclc.org/bibformats/en/0xx/020.html 020 field}
+      # and related {https://www.oclc.org/bibformats/en/8xx/880.html 880 field}.
+      #
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      # @todo look into z subfield for 020 field, should we show cancelled isbn?
+      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?
+        end
+        isbn_values += linked_alternate(record, '020', &subfield_in?(%w[a z]))
+        isbn_values
+      end
+
+      # Get ISSN values for display from the {https://www.oclc.org/bibformats/en/0xx/022.html 022 field} and related
+      # {https://www.oclc.org/bibformats/en/8xx/880.html 880 field}.
+      #
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      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?
+        end
+        issn_values += linked_alternate(record, '022', &subfield_in?(%w[a z]))
+        issn_values
+      end
+
+      # Get numeric OCLC ID of first {https://www.oclc.org/bibformats/en/0xx/035.html 035 field}
+      # with an OCLC ID defined in subfield 'a'.
+      #
+      # @todo We should evaluate this to return a single value in the future since subfield a is non-repeatable
+      # @param [MARC::Record] record
+      # @return [Array<String>]
+      def oclc_id(record)
+        oclc_id = Array.wrap(record.fields('035')
+                         .find { |field| field.any? { |subfield| subfield_a_is_oclc?(subfield) } })
+
+        oclc_id.flat_map do |field|
+          field.filter_map do |subfield|
+            # skip unless subfield 'a' is an oclc id value
+            next unless subfield_a_is_oclc?(subfield)
+
+            # search for numeric part of oclc id (e.g. '610094484' in '(OCoLC)ocn610094484')
+            match = /^\s*\(OCoLC\)[^1-9]*([1-9][0-9]*).*$/.match(subfield.value)
+
+            # skip unless search to find numeric part of oclc id has a match
+            next unless match
+
+            match[1]
+          end
+        end
+      end
+
+      # Get publisher issued identifiers from fields {https://www.oclc.org/bibformats/en/0xx/024.html 024},
+      # {https://www.oclc.org/bibformats/en/0xx/024.html 028}, and related
+      # {https://www.oclc.org/bibformats/en/8xx/880.html 880 field}.
+      #
+      # @param [MARC::Record] record
+      # @return [Array<string>]
+      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?
+        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}.
+      #
+      # @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?
+        end
+      end
+
+      private
+
+      # Determine if subfield 'a' is an OCLC id.
+      #
+      # @param [MARC::Subfield]
+      # @return [TrueClass, FalseClass]
+      def subfield_a_is_oclc?(subfield)
+        subfield.code == 'a' && subfield.value =~ /^\(OCoLC\).*/
+      end
+
+      # Normalize isbn value using {https://github.com/billdueber/library_stdnums library_stdnums gem}.
+      # Converts ISBN10 (ten-digit) to validated ISBN13 (thriteen-digit) and returns both values. If passed
+      # ISBN13 parameter, only returns validated ISBN13 value.
+      #
+      #  @param [String] isbn
+      #  @return [Array<String, String>, nil]
+      def normalize_isbn(isbn)
+        StdNum::ISBN.allNormalizedValues(isbn)
+      end
+    end
+  end
+end

data/lib/pennmarc/helpers/language.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module PennMARC
+  # Logic for extracting and translating Language values for a record. Penn practice is to verify the value present in
+  # the {https://www.oclc.org/bibformats/en/fixedfield/lang.html 008 control field} as a three letter code. This code
+  # is then mapped to a display-friendly value using the a provided mapping hash.
+  # @todo should we consider values in the {https://www.oclc.org/bibformats/en/0xx/041.html 041 field}?
+  class Language < Helper
+    # Used when no value is present in the control field - still mapped
+    UNDETERMINED_CODE = :und
+
+    class << self
+      # Get language values for display from the {https://www.oclc.org/bibformats/en/5xx/546.html 546 field} and
+      # related 880.
+      # @param [MARC::Record] record
+      # @return [Array<String>] language values and notes
+      def show(record)
+        values = record.fields('546').map do |field|
+          join_subfields field, &subfield_not_in?(%w[6 8])
+        end
+        values + linked_alternate(record, '546', &subfield_not_in?(%w[6 8]))
+      end
+
+      # Get language values for searching and faceting of a record. The value is extracted from a defined position in
+      # 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
+      # @return [String] nice value for language
+      def search(record, mapping)
+        control_field = record['008']&.value
+        language_code = control_field[35..37]
+        mapping[language_code.to_sym || UNDETERMINED_CODE]
+      end
+    end
+  end
+end

data/lib/pennmarc/helpers/link.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module PennMARC
+  # Do Link-y stuff
+  class Link < Helper
+    class << self
+      def full_text(record:); end
+
+      def web(record:); end
+    end
+  end
+end