pennmarc 0.0.1

data/lib/pennmarc/mappings/relator.yml

@@ -0,0 +1,263 @@
+abr: Abridger
+act: Actor
+adp: Adapter
+rcp: Addressee
+anl: Analyst
+anm: Animator
+ann: Annotator
+apl: Appellant
+ape: Appellee
+app: Applicant
+arc: Architect
+arr: Arranger
+acp: Art copyist
+adi: Art director
+art: Artist
+ard: Artistic director
+asg: Assignee
+asn: Associated name
+att: Attributed name
+auc: Auctioneer
+aut: Author
+aqt: Author in quotations or text abstracts
+aft: Author of afterword, colophon, etc.
+aud: Author of dialog
+aui: Author of introduction, etc.
+ato: Autographer
+ant: Bibliographic antecedent
+bnd: Binder
+bdd: Binding designer
+blw: Blurb writer
+bkd: Book designer
+bkp: Book producer
+bjd: Bookjacket designer
+bpd: Bookplate designer
+bsl: Bookseller
+brl: Braille embosser
+brd: Broadcaster
+cll: Calligrapher
+ctg: Cartographer
+cas: Caster
+cns: Censor
+chr: Choreographer
+cng: Cinematographer
+cli: Client
+-clb: Collaborator
+cor: Collection registrar
+col: Collector
+clt: Collotyper
+clr: Colorist
+cmm: Commentator
+cwt: Commentator for written text
+com: Compiler
+cpl: Complainant
+cpt: Complainant-appellant
+cpe: Complainant-appellee
+cmp: Composer
+cmt: Compositor
+ccp: Conceptor
+cnd: Conductor
+con: Conservator
+csl: Consultant
+csp: Consultant to a project
+cos: Contestant
+cot: Contestant-appellant
+coe: Contestant-appellee
+cts: Contestee
+ctt: Contestee-appellant
+cte: Contestee-appellee
+ctr: Contractor
+ctb: Contributor
+cpc: Copyright claimant
+cph: Copyright holder
+crr: Corrector
+crp: Correspondent
+cst: Costume designer
+cou: Court governed
+crt: Court reporter
+cov: Cover designer
+cre: Creator
+cur: Curator
+dnc: Dancer
+dtc: Data contributor
+dtm: Data manager
+dte: Dedicatee
+dto: Dedicator
+dfd: Defendant
+dft: Defendant-appellant
+dfe: Defendant-appellee
+dgg: Degree granting institution
+dln: Delineator
+dpc: Depicted
+dpt: Depositor
+dsr: Designer
+drt: Director
+dis: Dissertant
+dbp: Distribution place
+dst: Distributor
+dnr: Donor
+drm: Draftsman
+dub: Dubious author
+edt: Editor
+edc: Editor of compilation
+edm: Editor of moving image work
+elg: Electrician
+elt: Electrotyper
+enj: Enacting jurisdiction
+eng: Engineer
+egr: Engraver
+etr: Etcher
+evp: Event place
+exp: Expert
+fac: Facsimilist
+fld: Field director
+fds: Film distributor
+fmd: Film director
+flm: Film editor
+fmp: Film producer
+fmk: Filmmaker
+fpy: First party
+frg: Forger
+fmo: Former owner
+fnd: Funder
+gis: Geographic information specialist
+-grt: Graphic technician
+hnr: Honoree
+hst: Host
+his: Host institution
+ilu: Illuminator
+ill: Illustrator
+ins: Inscriber
+itr: Instrumentalist
+ive: Interviewee
+ivr: Interviewer
+inv: Inventor
+isb: Issuing body
+jud: Judge
+jug: Jurisdiction governed
+lbr: Laboratory
+ldr: Laboratory director
+lsa: Landscape architect
+led: Lead
+len: Lender
+lil: Libelant
+lit: Libelant-appellant
+lie: Libelant-appellee
+lel: Libelee
+let: Libelee-appellant
+lee: Libelee-appellee
+lbt: Librettist
+lse: Licensee
+lso: Licensor
+lgd: Lighting designer
+ltg: Lithographer
+lyr: Lyricist
+mfp: Manufacture place
+mfr: Manufacturer
+mrb: Marbler
+mrk: Markup editor
+mdc: Metadata contact
+mte: Metal-engraver
+mod: Moderator
+mon: Monitor
+mcp: Music copyist
+msd: Musical director
+mus: Musician
+nrt: Narrator
+osp: Onscreen presenter
+opn: Opponent
+orm: Organizer of meeting
+org: Originator
+own: Owner
+pan: Panelist
+ppm: Papermaker
+pta: Patent applicant
+pth: Patent holder
+pat: Patron
+prf: Performer
+pma: Permitting agency
+pht: Photographer
+ptf: Plaintiff
+ptt: Plaintiff-appellant
+pte: Plaintiff-appellee
+plt: Platemaker
+pra: Praeses
+pre: Presenter
+prt: Printer
+pop: Printer of plates
+prm: Printmaker
+prc: Process contact
+pro: Producer
+prn: Production company
+prs: Production designer
+pmn: Production manager
+prd: Production personnel
+prp: Production place
+prg: Programmer
+pdr: Project director
+pfr: Proofreader
+prv: Provider
+pup: Publication place
+pbl: Publisher
+pbd: Publishing director
+ppt: Puppeteer
+rdd: Radio director
+rpc: Radio producer
+rce: Recording engineer
+rcd: Recordist
+red: Redaktor
+ren: Renderer
+rpt: Reporter
+rps: Repository
+rth: Research team head
+rtm: Research team member
+res: Researcher
+rsp: Respondent
+rst: Respondent-appellant
+rse: Respondent-appellee
+rpy: Responsible party
+rsg: Restager
+rsr: Restorationist
+rev: Reviewer
+rbr: Rubricator
+sce: Scenarist
+sad: Scientific advisor
+aus: Screenwriter
+scr: Scribe
+scl: Sculptor
+spy: Second party
+sec: Secretary
+sll: Seller
+std: Set designer
+stg: Setting
+sgn: Signer
+sng: Singer
+sds: Sound designer
+spk: Speaker
+spn: Sponsor
+sgd: Stage director
+stm: Stage manager
+stn: Standards body
+str: Stereotyper
+stl: Storyteller
+sht: Supporting host
+srv: Surveyor
+tch: Teacher
+tcd: Technical director
+tld: Television director
+tlp: Television producer
+ths: Thesis advisor
+trc: Transcriber
+trl: Translator
+tyd: Type designer
+tyg: Typographer
+uvp: University place
+vdg: Videographer
+-voc: Vocalist
+wit: Witness
+wde: Wood engraver
+wdc: Woodcutter
+wam: Writer of accompanying material
+wac: Writer of added commentary
+wat: Writer of added text
+wal: Writer of added lyrics

data/lib/pennmarc/parser.rb

@@ -0,0 +1,177 @@
+# frozen_string_literal: true
+
+require 'active_support/all'
+require_relative 'helpers/helper'
+require_relative 'helpers/creator'
+require_relative 'helpers/database'
+require_relative 'helpers/date'
+require_relative 'helpers/format'
+require_relative 'helpers/genre'
+require_relative 'helpers/identifier'
+require_relative 'helpers/language'
+require_relative 'helpers/link'
+require_relative 'helpers/location'
+require_relative 'helpers/subject'
+require_relative 'helpers/title'
+require_relative 'helpers/citation'
+require_relative 'helpers/relation'
+require_relative 'helpers/production'
+require_relative 'helpers/edition'
+require_relative 'helpers/note'
+
+module PennMARC
+  attr_accessor :mappings
+
+  DEFINED_HELPERS = %w[Creator Database Date Format Genre Language Link Location Subject Title Relation].freeze
+
+  # Methods here should return values used in the indexer. The parsing logic should
+  # NOT return values specific to any particular site/interface, but just general
+  # MARC parsing logic for "title", "subject", "author", etc., as much as reasonably
+  # possible. We'll see how it goes.
+  #
+  # Methods should, by default, take in a MARC::Record
+  class Parser
+    def initialize(helpers: DEFINED_HELPERS)
+      @mappings = {}
+      @helpers = Array.wrap(helpers) # TODO: load helpers dynamically?
+    end
+
+    def respond_to_missing?(name)
+      name.split('_').first.in? @helpers
+    end
+
+    # Call helper class methods, e.g.,
+    # #title_show -> PennMARC::Title.show
+    # #subject_facet -> PennMARC::Subject.facet
+    def method_missing(name, opts)
+      call = name.to_s.split('_')
+      helper = call.shift
+      meth = call.join('_')
+      "PennMARC::#{helper.titleize}".constantize.public_send(meth, opts)
+    end
+
+    # @todo does this fit in an existing helper?
+    # @param [MARC::Record] record
+    # @return [Object]
+    def cartographic_show(record)
+      record.fields(%w{255 342}).map do |field|
+        join_subfields(field, &subfield_not_6_or_8)
+      end
+    end
+
+    # @todo move to Identifier helper
+    # @param [MARC::Record] record
+    # @return [Object]
+    def fingerprint_show(record)
+      record.fields('026').map do |field|
+        join_subfields(field, &subfield_not_in(%w{2 5 6 8}))
+      end
+    end
+
+    # @todo does this fit in an existing helper?
+    # @param [MARC::Record] record
+    # @return [Object]
+    def arrangement_show(record)
+      get_datafield_and_880(record, '351')
+    end
+
+    # @param [MARC::Record] record
+    # @return [Object]
+    def system_details_show(record)
+      acc = []
+      acc += record.fields('538').map do |field|
+        get_sub3_and_other_subs(field, &subfield_in(%w{a i u}))
+      end
+      acc += record.fields('344').map do |field|
+        get_sub3_and_other_subs(field, &subfield_in(%w{a b c d e f g h}))
+      end
+      acc += record.fields(%w{345 346}).map do |field|
+        get_sub3_and_other_subs(field, &subfield_in(%w{a b}))
+      end
+      acc += record.fields('347').map do |field|
+        get_sub3_and_other_subs(field, &subfield_in(%w{a b c d e f}))
+      end
+      acc += record.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 += record.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 += record.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 += record.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
+
+    # @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_show(record); end
+
+    # @todo move this to Creator helper
+    # @param [MARC::Record] record
+    # @return [Object]
+    def contributor_show(record)
+      acc = []
+      acc += record.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 += record.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
+
+    # Load language map from YAML and memoize in @mappings hash
+    # @return [Hash]
+    def language_map
+      @mappings[:language] ||= load_map('language.yml')
+    end
+
+    # Load location map from YAML and memoize in @mappings hash
+    # @return [Hash]
+    def location_map
+      @mappings[:location] ||= load_map('locations.yml')
+    end
+
+    # Load relator map from YAML and memoize in @mappings hash
+    # @return [Hash]
+    def relator_map
+      @mappings[:relator] ||= load_map('relator.yml')
+    end
+
+    # @param [String] filename of mapping file in config directory, with file extension
+    # @return [Hash] mapping as hash
+    def load_map(filename)
+      YAML.safe_load(File.read(File.join(File.expand_path(__dir__), 'mappings', filename)),
+                     symbolize_names: true)
+    end
+  end
+end

data/lib/pennmarc/util.rb

@@ -0,0 +1,240 @@
+# frozen_string_literal: true
+
+require_relative 'heading_control'
+
+module PennMARC
+  # class to hold "utility" methods used in MARC parsing methods
+  module Util
+    # Join subfields from a field selected based on a provided proc
+    # @param [MARC::DataField] field
+    # @param [Proc] selector
+    # @return [String]
+    def join_subfields(field, &selector)
+      field.select { |v| selector.call(v) }.filter_map { |sf|
+        value = sf.value&.strip
+        next unless value.present?
+
+        value
+      }.join(' ').squish
+    end
+
+    # returns true if field has a value that matches
+    # passed-in regex and passed in subfield
+    # @todo example usage
+    # @param [MARC::DataField] field
+    # @param [String|Integer|Symbol] subfield
+    # @param [Regexp] regex
+    # @return [TrueClass, FalseClass]
+    def subfield_value?(field, subfield, regex)
+      field.any? { |sf| sf.code == subfield.to_s && sf.value =~ regex }
+    end
+
+    # returns true if a given field has a given subfield value in a given array
+    # TODO: example usage
+    # @param [MARC:DataField] field
+    # @param [String|Integer|Symbol] subfield
+    # @param [Array] array
+    # @return [TrueClass, FalseClass]
+    def subfield_value_in?(field, subfield, array)
+      field.any? { |sf| sf.code == subfield.to_s && sf.value.in?(array) }
+    end
+
+    # returns true if a given field does not have a given subfield value in a given array
+    # @param [MARC:DataField] field
+    # @param [String|Integer|Symbol] subfield
+    # @param [Array] array
+    # @return [TrueClass, FalseClass
+    def subfield_value_not_in?(field, subfield, array)
+      field.none? { |sf| sf.code == subfield.to_s && sf.value.in?(array) }
+    end
+
+    # returns a lambda checking if passed-in subfield's code is a member of array
+    # TODO: include lambda returning methods in their own module?
+    # @param [Array] array
+    # @return [Proc]
+    def subfield_in?(array)
+      ->(subfield) { array.member?(subfield.code) }
+    end
+
+    # returns a lambda checking if passed-in subfield's code is NOT a member of array
+    # TODO: include lambda returning methods in their own module?
+    # @param [Array] array
+    # @return [Proc]
+    def subfield_not_in?(array)
+      ->(subfield) { !array.member?(subfield.code) }
+    end
+
+    # Check if a field has a given subfield defined
+    # @param [MARC::DataField] field
+    # @param [String|Symbol|Integer] subfield
+    # @return [TrueClass, FalseClass]
+    def subfield_defined?(field, subfield)
+      field.any? { |sf| sf.code == subfield.to_s }
+    end
+
+    # Check if a field does not have a given subfield defined
+    # @param [MARC::DataField] field
+    # @param [String|Symbol|Integer] subfield
+    # @return [TrueClass, FalseClass]
+    def subfield_undefined?(field, subfield)
+      field.none? { |sf| sf.code == subfield.to_s }
+    end
+
+    # Gets all subfield values for a subfield in a given field
+    # @param [MARC::DataField] field
+    # @param [String|Symbol] subfield as a string or symbol
+    # @return [Array] subfield values for given subfield code
+    def subfield_values(field, subfield)
+      field.filter_map do |sf|
+        next unless sf.code == subfield.to_s
+
+        next unless sf.value.present?
+
+        sf.value
+      end
+    end
+
+    # Get all subfield values for a provided subfield from any occurrence of a provided tag/tags
+    # @param [String|Array] tag tags to consider
+    # @param [String|Symbol] subfield to take the values from
+    # @param [MARC::Record] record source
+    # @return [Array] array of subfield values
+    def subfield_values_for(tag:, subfield:, record:)
+      record.fields(tag).flat_map do |field|
+        subfield_values field, subfield
+      end
+    end
+
+    # @param [Symbol|String] trailer to target for removal
+    # @param [String] string to modify
+    def trim_trailing(trailer, string)
+      map = { semicolon: /\s*;\s*$/,
+              colon: /\s*:\s*$/,
+              equal: /=$/,
+              slash: %r{\s*/\s*$},
+              comma: /\s*,\s*$/,
+              period: /\.\s*$/ } # TODO: revise to exclude "etc."
+      string.sub map[trailer.to_sym], ''
+    end
+
+    # MARC 880 field "Alternate Graphic Representation" contains text "linked" to another
+    # field (e.g., 254 [Title]) used as an alternate representation. Often used to hold
+    # translations of title values. A common need is to extract subfields as selected by
+    # passed-in block from 880 datafield that has a particular subfield 6 value.
+    # See: https://www.loc.gov/marc/bibliographic/bd880.html
+    # @param [MARC::Record] record
+    # @param [String|Array] subfield6_value either a string to look for in sub6 or an array of them
+    # @param selector [Proc] takes a subfield as argument, returns a boolean
+    # @return [Array] array of linked alternates
+    def linked_alternate(record, subfield6_value, &selector)
+      record.fields('880').filter_map do |field|
+        next unless subfield_value?(field, '6', /^#{Array.wrap(subfield6_value).join('|')}/)
+
+        field.select { |sf| selector.call(sf) }.map(&:value).join(' ')
+      end
+    end
+    alias get_880 linked_alternate
+
+    # Common case of wanting to extract all the subfields besides 6 or 8,
+    # from 880 datafield that has a particular subfield 6 value. We exclude 6 because
+    # that value is the linkage ID itself and 8 because... IDK
+    # @param [MARC::Record] record
+    # @param [String|Array] subfield6_value either a string to look for in sub6 or an array of them
+    # @return [Array] array of linked alternates without 8 or 6 values
+    def linked_alternate_not_6_or_8(record, subfield6_value)
+      linked_alternate(record, subfield6_value) do |sf|
+        %w[6 8].exclude?(sf.code)
+      end
+    end
+
+    # Returns the non-6,8 subfields from a datafield and its 880 link.
+    # @param [MARC::Record] record
+    # @param [String] tag
+    # @return [Array] acc
+    def datafield_and_linked_alternate(record, tag)
+      record.fields(tag).filter_map do |field|
+        join_subfields(field, &subfield_not_in?(%w[6 8]))
+      end + linked_alternate_not_6_or_8(record, tag)
+    end
+
+    # Get the substring of a string up to a given target character
+    # @param [Object] string to split
+    # @param [Object] target character to split upon
+    # @return [String (frozen)]
+    def substring_before(string, target)
+      string.scan(target).present? ? string.split(target, 2).first : ''
+    end
+
+    # Get the substring of a string after the first occurrence of a target character
+    # @param [Object] string to split
+    # @param [Object] target character to split upon
+    # @return [String (frozen)]
+    def substring_after(string, target)
+      string.scan(target).present? ? string.split(target, 2).second : ''
+    end
+
+    # Join array and normalizing extraneous spaces
+    # @param [Array] array
+    # @return [String]
+    def join_and_squish(array)
+      array.join(' ').squish
+    end
+    alias join_and_trim_whitespace join_and_squish
+
+    # If there's a subfield i, extract its value, and if there's something
+    # in parentheses in that value, extract that.
+    # @param [MARC::Field] field
+    # @return [String] subfield i without parentheses value
+    def remove_paren_value_from_subfield_i(field)
+      val = field.filter_map do |sf|
+        next unless sf.code == 'i'
+
+        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
+
+    # Translate a relator code using mapping
+    # @todo handle case of receiving a URI? E.g., http://loc.gov/relator/aut
+    # @param [String, NilClass] relator_code
+    # @param [Hash] mapping
+    # @return [String, NilClass] full relator string
+    def translate_relator(relator_code, mapping)
+      return unless relator_code.present?
+
+      mapping[relator_code.to_sym]
+    end
+
+    # Get 650 & 880 for Provenance and Chronology: prefix should be 'PRO' or 'CHR' and may be preceded by a '%'
+    # @note 11/2018: do not display $5 in PRO or CHR subjs
+    # @param [MARC::Record] record
+    # @param [String] prefix to select from subject field
+    # @return [Array] array of values
+    def prefixed_subject_and_alternate(record, prefix)
+      record.fields(%w[650 880]).filter_map do |field|
+        next unless field.indicator2 == '4'
+
+        next if field.tag == '880' && subfield_values(field, '6').exclude?('650')
+
+        next unless field.any? { |sf| sf.code == 'a' && sf.value =~ /^(#{prefix}|%#{prefix})/ }
+
+        elements = field.select(&subfield_in?(%w[a])).map { |sf| sf.value.gsub(/^%?#{prefix}/, '') }
+        elements << join_subfields(field, &subfield_not_in?(%w[a 6 8 e w 5]))
+        join_and_squish elements
+      end
+    end
+
+    # Does the given field specify an allowed source code?
+    #
+    # @param [MARC::DataField] field
+    # @return [Boolean]
+    def valid_subject_genre_source_code?(field)
+      subfield_value_in?(field, '2', PennMARC::HeadingControl::ALLOWED_SOURCE_CODES)
+    end
+  end
+end

data/lib/pennmarc.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+$LOAD_PATH.unshift(__dir__) unless $LOAD_PATH.include?(__dir__)
+
+require_relative 'pennmarc/parser'
+require 'library_stdnums'

data/pennmarc.gemspec

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+Gem::Specification.new do |s|
+  s.name        = 'pennmarc'
+  s.version     = '0.0.1'
+  s.summary     = 'Penn Libraries Catalog MARC parsing wisdom for cross-project usage'
+  s.description = 'Penn Libraries Catalog MARC parsing wisdom for cross-project usage'
+  s.authors     = ['Mike Kanning', 'Amrey Mathurin', 'Patrick Perkins']
+  s.email       = 'mkanning@upenn.edu'
+  s.files       = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  s.homepage    = 'https://gitlab.library.upenn.edu/dld/catalog/pennmarc'
+  s.license     = 'MIT'
+
+  s.required_ruby_version = '>= 3.2'
+
+  s.add_dependency 'marc'
+
+  s.add_development_dependency 'nokogiri'
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'simplecov'
+  s.add_development_dependency 'upennlib-rubocop'
+end