berkeley_library-av-core 0.4.0

data/lib/berkeley_library/av/core/module_info.rb

@@ -0,0 +1,18 @@
+module BerkeleyLibrary
+  module AV
+    module Core
+      class ModuleInfo
+        NAME = 'berkeley_library-av-core'.freeze
+        AUTHOR = 'David Moles'.freeze
+        AUTHOR_EMAIL = 'dmoles@berkeley.edu'.freeze
+        SUMMARY = 'UC Berkeley Library audio/video core code'.freeze
+        DESCRIPTION = 'Gem for UC Berkeley Library shared audio/video code'.freeze
+        LICENSE = 'MIT'.freeze
+        VERSION = '0.4.0'.freeze
+        HOMEPAGE = 'https://git.lib.berkeley.edu/lap/av_core'.freeze
+
+        private_class_method :new
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/core.rb

@@ -0,0 +1,7 @@
+require 'berkeley_library/av/config'
+require 'berkeley_library/av/marc'
+require 'berkeley_library/av/metadata'
+require 'berkeley_library/av/record'
+require 'berkeley_library/av/record_id'
+require 'berkeley_library/av/track'
+require 'berkeley_library/av/util'

data/lib/berkeley_library/av/marc/util.rb

@@ -0,0 +1,114 @@
+require 'marc'
+require 'berkeley_library/av/util'
+
+module BerkeleyLibrary
+  module AV
+    module Marc
+      module Util
+        include AV::Util
+
+        # Extracts the subfield values from the specifed MARC data field and
+        # returns the groups of related subfield values in order as they
+        # appear. For instance, for the following data field:
+        #
+        # ```
+        # 505  00$tQuatrain II$g(16:35) --$tWater ways$g(1:57) --$tWaves$g(10:49).
+        # ```
+        #
+        # this method would return:
+        #
+        # ```
+        # [
+        #   {t: 'Quatrain II', g: '(16:35)'},
+        #   {t: 'Water ways', g: '(01:57)'},
+        #   {t: 'Waves', g: '(10:49)'}
+        # ]
+        # ```
+        #
+        # If an order is provided, each group will be reordered according to
+        # that order. E.g., given the order `[:g, :t]`, the above would be
+        # returned instead as:
+        #
+        # ```
+        # [
+        #   {g: '(16:35)', t: 'Quatrain II'},
+        #   {g: '(01:57)', t: 'Water ways'},
+        #   {g: '(10:49)', t: 'Waves'},
+        # ]
+        # ```
+        #
+        # @param data_field [MARC::DataField] the data field
+        # @param order [Array<Symbol>, nil] the order of subfield codes
+        # @return [Array<Hash<Symbol, String>>] the grouped values
+        def group_subfield_values(data_field, order: nil)
+          # TODO: do we still need this?
+          grouped_subfields = group_subfields(data_field.subfields, order:)
+          grouped_subfields.each_with_object([]) do |subfield_group, value_groups|
+            value_group = subfield_group.transform_values { |sf| tidy_value(sf.value) }
+            value_groups << value_group
+          end
+        end
+
+        # Extracts the subfieldsfrom the specifed MARC data field and
+        # returns the groups of related subfieldsin order as they
+        # appear. For instance, for the following data field:
+        #
+        # ```
+        # 505  00$tQuatrain II$g(16:35) --$tWater ways$g(1:57) --$tWaves$g(10:49).
+        # ```
+        #
+        # this method would return:
+        #
+        # ```
+        # [
+        #   {t: #<Subfield @code='t', @value='Quatrain II'>, g: #<Subfield @code='g', @value='(16:35)'>},
+        #   {t: #<Subfield @code='t', @value='Water ways'>, g: #<Subfield @code='g', @value='(01:57)'>},
+        #   {t: #<Subfield @code='t', @value='Waves'>, g: #<Subfield @code='g', @value='(10:49)'>}
+        # ]
+        # ```
+        #
+        # If an order is provided, each group will be reordered according to
+        # that order. E.g., given the order `[:g, :t]`, the above would be
+        # returned instead as:
+        #
+        # ```
+        # [
+        #   {g: #<Subfield @code='g', @value='(16:35)'>, t: #<Subfield @code='t', @value='Quatrain II'>},
+        #   {g: #<Subfield @code='g', @value='(01:57)'>, t: #<Subfield @code='t', @value='Water ways'>},
+        #   {g: #<Subfield @code='g', @value='(10:49)'>, t: #<Subfield @code='t', @value='Waves'>},
+        # ]
+        # ```
+        #
+        # @param data_field [MARC::DataField] the data field
+        # @param order [Array<Symbol>, nil] the order of subfield codes
+        # @return [Array<Hash<Symbol, String>>] the grouped values
+        def group_subfields(subfields, order: nil)
+          by_code = subfields_by_code(subfields)
+          order = by_code.keys if order.nil? || order.empty?
+          group_by_code(by_code, order)
+        end
+
+        private
+
+        def subfields_by_code(subfields)
+          subfields.each_with_object({}) do |sf, h|
+            (h[sf.code.to_sym] ||= []) << sf
+          end
+        end
+
+        def group_by_code(subfields_by_code, order)
+          order.each_with_object([]) do |code, groups|
+            csym = code.to_sym
+            next unless (subfields = subfields_by_code[csym])
+
+            subfields.each_with_index { |v, i| (groups[i] ||= {})[csym] = v }
+          end
+        end
+
+        class << self
+          include AV::Marc::Util
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/marc.rb

@@ -0,0 +1,52 @@
+require 'marc'
+
+module BerkeleyLibrary
+  module AV
+    module Marc
+      class << self
+        # Parses MARCXML.
+        #
+        # @param xml [String] the XML to parse
+        # @return [MARC::Record, nil] the MARC record from the specified XML
+        def from_xml(xml)
+          # noinspection RubyYardReturnMatch,RubyMismatchedReturnType
+          all_from_xml(xml).first
+        end
+
+        # Parses MARCXML.
+        #
+        # @param xml [String] the XML to parse
+        # @return [MARC::XMLReader] the MARC records
+        def all_from_xml(xml)
+          input = StringIO.new(xml.scrub)
+          MARC::XMLReader.new(input)
+        end
+
+        # Returns a reader for the specified MARC file.
+        #
+        # @param marc_path [String] the path to a MARC file in XML or binary format
+        # @param external_encoding [String] the encoding, for binary files
+        # @return [MARC::XMLReader] if the file path ends in `.xml`
+        # @return [MARC::Reader] if the file path ends in `.mrc`
+        def reader_for(marc_path, external_encoding: 'MARC-8')
+          downcased_path = marc_path.downcase
+          return MARC::XMLReader.new(marc_path) if downcased_path.end_with?('.xml')
+          return MARC::Reader.new(marc_path, external_encoding:) if downcased_path.end_with?('.mrc')
+
+          raise ArgumentError, "Unable to determine reader needed for MARC file #{marc_path.inspect}"
+        end
+
+        # Returns a MARC record read from the specified file (or the first record
+        # if the file contains multiple records).
+        #
+        # @param marc_path [String] the path to a MARC file in XML or binary format
+        # @param external_encoding [String] the encoding, for binary files
+        # @return [MARC::Record] the MARC record
+        def read(marc_path, external_encoding: 'MARC-8')
+          # noinspection RubyYardReturnMatch
+          reader_for(marc_path, external_encoding:).first
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/metadata/README.md

@@ -0,0 +1,5 @@
+# `tind_html_metadata_da.json`
+
+This file contains a snapshot of JSON data extracted from the HTML source of the
+[TIND Record Page Configuration Interface](https://digicoll.lib.berkeley.edu/displays/?ln=en&section=tind_html_metadata_da),
+defining the labels, visibility, and order of the MARC fields on the TIND record display page.

data/lib/berkeley_library/av/metadata/field.rb

@@ -0,0 +1,110 @@
+require 'berkeley_library/av/constants'
+require 'berkeley_library/av/marc/util'
+require 'berkeley_library/av/metadata/value'
+require 'marc/spec'
+
+module BerkeleyLibrary
+  module AV
+    class Metadata
+      class Field
+        include AV::Marc::Util
+        include Comparable
+
+        # ------------------------------------------------------------
+        # Constants
+
+        SPEC_TAG_RE = /^([0-9a-z.]{3})/
+
+        # ------------------------------------------------------------
+        # Accessors
+
+        attr_reader :order, :label, :tag, :spec, :query, :subfields_separator, :subfield_order
+
+        # ------------------------------------------------------------
+        # Initializer
+
+        # rubocop:disable Metrics/ParameterLists
+        def initialize(order:, label:, spec:, tag: nil, subfields_separator: ' ', subfield_order: [])
+          @order = order
+          @label = label
+          @spec = spec
+          @query = MARC::Spec.parse_query(spec)
+          @tag = tag || query.tag_str
+          @subfields_separator = subfields_separator
+          @subfield_order = subfield_order
+        end
+        # rubocop:enable Metrics/ParameterLists
+
+        # ------------------------------------------------------------
+        # Public methods
+
+        def value_from(marc_record)
+          results = MARC::Spec.execute_query(query, marc_record)
+          subfield_groups = subfield_groups_from_result(results)
+          Value.value_for(self, subfield_groups)
+        end
+
+        def same_metadata?(other)
+          raise ArgumentError, "Not a #{class_name(self)}: #{other}" unless other.is_a?(Field)
+
+          %i[tag query subfields_separator subfield_order].all? do |attr|
+            (other.respond_to?(attr) && send(attr) == other.send(attr))
+          end
+        end
+
+        # ------------------------------
+        # Object
+
+        def to_s
+          "#{order}. #{query} #{label.inspect}".tap do |str|
+            str << " #{subfields_separator.inspect}" unless subfields_separator == ' '
+            str << " $#{subfield_order.join('$')}" unless subfield_order.empty?
+          end
+        end
+
+        def inspect
+          "#<#{class_name(self)} #{self}>"
+        end
+
+        def hash
+          sort_attrs.map { |a| send(a) }.hash
+        end
+
+        # ------------------------------
+        # Comparable
+
+        def <=>(other)
+          compare_by_attributes(self, other, *sort_attrs)
+        end
+
+        # ------------------------------------------------------------
+        # Private
+
+        private
+
+        def sort_attrs
+          %i[order tag query subfields_separator label subfield_order]
+        end
+
+        def subfield_groups_from_result(marc_result)
+          if marc_result.is_a?(Array)
+            return [] if marc_result.empty?
+            return marc_result.map { |r| subfield_groups_from_result(r) }.flatten unless marc_result[0].is_a?(MARC::Subfield)
+          end
+
+          subfields = subfields_from_result(marc_result)
+          group_subfields(subfields, order: subfield_order)
+        end
+
+        def subfields_from_result(marc_result)
+          return marc_result if marc_result.is_a?(Array) && marc_result[0].is_a?(MARC::Subfield)
+          return [marc_result] if marc_result.is_a?(MARC::Subfield)
+          return [] unless marc_result.respond_to?(:subfields)
+
+          marc_result.subfields
+        end
+
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/metadata/fields.rb

@@ -0,0 +1,130 @@
+require 'berkeley_library/av/metadata/field'
+
+module BerkeleyLibrary
+  module AV
+    class Metadata
+      module Fields
+        include AV::Constants
+
+        TITLE = Field.new(order: 1, label: 'Title', spec: "#{TAG_TITLE_FIELD}$a")
+
+        DESCRIPTION = Field.new(order: 2, label: 'Description', spec: '520$a')
+        CREATOR_PERSONAL = Field.new(order: 2, label: 'Creator', spec: '700')
+        CREATOR_CORPORATE = Field.new(order: 2, label: 'Creator', spec: '710')
+        TRACKS = Field.new(order: 99, label: 'Tracks', spec: TAG_TRACK_FIELD, subfield_order: %w[g t a])
+        CATALOG_LINK = Field.new(order: 999, label: 'Linked Resources', spec: "#{TAG_LINK_FIELD}{^1=\\4}{^2=\\1}")
+
+        STANDARD_FIELDS = [
+          TITLE,
+          DESCRIPTION,
+          CREATOR_PERSONAL,
+          CREATOR_CORPORATE,
+          TRACKS,
+          CATALOG_LINK
+        ].freeze
+
+        TIND_CONFIG = File.join(__dir__, 'tind_html_metadata_da.json')
+
+        REQ_ATTRS = %w[visible params labels order].freeze
+        TAG_ATTRS = %w[tag fields tag_1 tag_2].freeze
+        TAG_RE = /(?<tag>[0-9]{3})(?<ind1>[a-z0-9_%])(?<ind2>[a-z0-9_%])(?<subfield>[a-z0-9])?/
+
+        class << self
+
+          def default_fields
+            @default_fields ||= begin
+              default_fields = STANDARD_FIELDS + from_tind_config(TIND_CONFIG)
+              unique_by_metadata(default_fields)
+            end
+          end
+
+          def from_tind_config(json_config)
+            json_config_hash = ensure_hash(json_config)
+            json_config_hash['config'].filter_map { |jf| to_field(jf) }
+          end
+
+          def default_values_from(marc_record)
+            default_fields.each_with_object({}) do |f, vv|
+              field_value = f.value_from(marc_record)
+              vv[f] = field_value if field_value
+            end
+          end
+
+          private
+
+          # @return [Hash] the config hash
+          def ensure_hash(json_config)
+            json_config = File.read(json_config) if File.file?(json_config)
+            json_config.is_a?(Hash) ? json_config : JSON.parse(json_config)
+          end
+
+          # rubocop:disable Metrics/MethodLength
+          def to_field(json_field)
+            return unless can_display?(json_field)
+
+            params = json_field['params']
+            tag, marc_spec = tag_and_spec_from(params)
+            return unless tag
+
+            Field.new(
+              order: json_field['order'].to_i,
+              label: json_field['labels']['en'],
+              tag:,
+              spec: marc_spec,
+              subfields_separator: (params['subfields_separator'] || ' '),
+              subfield_order: params['subfield_order'].to_s.split(',')
+            )
+          end
+          # rubocop:enable Metrics/MethodLength
+
+          def unique_by_metadata(fields)
+            fields.sort.each_with_object([]) do |f, uniques|
+              already_present = uniques.any? { |u| u.same_metadata?(f) }
+              uniques << f unless already_present
+            end
+          end
+
+          def can_display?(json_field)
+            REQ_ATTRS.all? { |f| json_field[f] } &&
+              json_field['labels'].key?('en') &&
+              json_field['machine_name'] != 'local_245_880_linking' # extra title
+          end
+
+          def tag_and_spec_from(params)
+            tag_and_spec = TAG_ATTRS.lazy.filter_map { |attr| parse_tag_and_spec(params[attr]) }.first
+            return tag_and_spec if tag_and_spec
+
+            return unless (input_tag = params['input_tag'])
+
+            input_subfield = params['input_subfield']
+            parse_tag_and_spec("#{input_tag}#{input_subfield}")
+          end
+
+          def parse_tag_and_spec(val)
+            return unless (md = TAG_RE.match(val))
+
+            tag = md[:tag]
+            [tag, to_marc_spec(tag, md[:ind1], md[:ind2], md[:subfield])]
+          end
+
+          def to_marc_spec(tag, ind1_val, ind2_val, subfield)
+            [
+              tag,
+              to_subfield_spec(subfield),
+              to_ind_spec(1, ind1_val),
+              to_ind_spec(2, ind2_val)
+            ].join
+          end
+
+          def to_subfield_spec(sf)
+            "$#{sf}" if sf
+          end
+
+          def to_ind_spec(i, ind_val)
+            "{^#{i}=\\#{ind_val}}" unless [nil, '', '%', '_'].include?(ind_val)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/metadata/link.rb

@@ -0,0 +1,28 @@
+module BerkeleyLibrary
+  module AV
+    class Metadata
+      class Link
+        include Comparable
+
+        attr_reader :body, :url
+
+        def initialize(body:, url:)
+          @body = body
+          @url = url
+        end
+
+        def to_s
+          "[#{body}](#{url})"
+        end
+
+        def <=>(other)
+          return unless other
+          return 0 if equal?(other)
+          return unless other.is_a?(Link)
+
+          to_s <=> other.to_s
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/metadata/readers/alma.rb

@@ -0,0 +1,54 @@
+require 'berkeley_library/util/uris'
+
+require 'berkeley_library/av/config'
+require 'berkeley_library/av/record_id'
+require 'berkeley_library/av/metadata/readers/base'
+
+module BerkeleyLibrary
+  module AV
+    class Metadata
+      module Readers
+        module Alma
+          include Base
+
+          def marc_uri_for(record_id)
+            query_string = URI.encode_www_form(
+              'version' => '1.2',
+              'operation' => 'searchRetrieve',
+              'query' => sru_query_value_for(record_id)
+            )
+
+            URIs.append(AV::Config.alma_sru_base_uri, '?', query_string)
+          end
+
+          protected
+
+          def _display_uri_for(record_id)
+            URIs.append(AV::Config.alma_permalink_base_uri, "alma#{record_id}")
+          end
+
+          private
+
+          def sru_query_value_for(record_id)
+            id_type = AV::RecordId::Type.for_id(record_id)
+            return "alma.mms_id=#{record_id}" if id_type == AV::RecordId::Type::ALMA
+            return millennium_query_value(record_id) if id_type == AV::RecordId::Type::MILLENNIUM
+
+            raise ArgumentError, "Invalid record type: #{id_type}"
+          end
+
+          def millennium_query_value(bib_number)
+            other_system_number = other_system_number_for_bib(bib_number)
+            "alma.other_system_number=#{other_system_number}"
+          end
+
+          def other_system_number_for_bib(bib_number)
+            bib_number = RecordId.ensure_check_digit(bib_number)
+            "UCB-#{bib_number}-#{AV::Config.alma_institution_code.downcase}"
+          end
+
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/metadata/readers/base.rb

@@ -0,0 +1,53 @@
+require 'berkeley_library/av/util'
+require 'berkeley_library/av/record_not_found'
+
+module BerkeleyLibrary
+  module AV
+    class Metadata
+      module Readers
+        module Base
+          include AV::Util
+
+          # @return [MARC::Record] the MARC record
+          def record_for(record_id)
+            first_record_for(record_id)
+          rescue AV::RecordNotFound
+            raise
+          rescue StandardError => e
+            raise not_found(record_id, e.message)
+          end
+
+          private
+
+          # @return [MARC::Record] the MARC record
+          def first_record_for(record_id)
+            marc_uri = marc_uri_for(record_id)
+            record_from(marc_uri, record_id)
+          end
+
+          def record_from(marc_uri, record_id)
+            xml = do_get(marc_uri)
+            AV::Marc.from_xml(xml).tap do |record|
+              raise not_found(record_id, "GET #{marc_uri} returned: #{xml}", marc_uri:) unless record
+            end
+          end
+
+          def not_found(record_id, details, marc_uri: nil)
+            msg = "Can't find #{name} record for ID #{record_id}: #{details}."
+
+            marc_uri_msg = marc_uri_message(record_id, marc_uri)
+            msg = [msg, marc_uri_msg].join(' ') if marc_uri_msg
+
+            AV::RecordNotFound.new(msg)
+          end
+
+          def marc_uri_message(record_id, marc_uri)
+            " MARC URI: #{marc_uri | marc_uri_for(record_id)}"
+          rescue StandardError
+            # nil
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/metadata/readers/tind.rb

@@ -0,0 +1,52 @@
+require 'berkeley_library/util/uris'
+
+require 'berkeley_library/av/config'
+require 'berkeley_library/av/record_id'
+require 'berkeley_library/av/metadata/readers/base'
+
+module BerkeleyLibrary
+  module AV
+    class Metadata
+      module Readers
+        module TIND
+          include Base
+
+          TIND_ID_FIELD = '035__a'.freeze
+
+          ID_FIELDS = {
+            AV::RecordId::Type::MILLENNIUM => '901__m'.freeze,
+            AV::RecordId::Type::OCLC => '901__o'.freeze
+          }.freeze
+
+          def marc_uri_for(record_id)
+            id_field = id_field_for(record_id)
+            query_string = URI.encode_www_form(
+              'p' => "#{id_field}:\"#{record_id}\"",
+              'of' => 'xm'
+            )
+            URIs.append(base_uri, 'search', '?', query_string)
+          end
+
+          protected
+
+          def _display_uri_for(record_id)
+            URIs.append(base_uri, 'record', record_id)
+          end
+
+          private
+
+          def base_uri
+            AV::Config.tind_base_uri
+          end
+
+          def id_field_for(record_id)
+            id_type = AV::RecordId::Type.for_id(record_id)
+            raise ArgumentError, "Can't look up Alma record #{record_id} in TIND" if id_type == AV::RecordId::Type::ALMA
+
+            ID_FIELDS[id_type] || TIND_ID_FIELD
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/metadata/readers.rb

@@ -0,0 +1,2 @@
+require 'berkeley_library/av/metadata/readers/alma'
+require 'berkeley_library/av/metadata/readers/tind'