berkeley_library-av-core 0.4.0

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

@@ -0,0 +1,121 @@
+require 'berkeley_library/util/uris'
+require 'berkeley_library/av/util'
+require 'berkeley_library/av/metadata/link'
+
+module BerkeleyLibrary
+  module AV
+    class Metadata
+      class Value
+        include AV::Util
+        include Comparable
+
+        # ------------------------------------------------------------
+        # Constants
+
+        URL_CODE = :u
+        BODY_CODES = %i[y z].freeze
+
+        # ------------------------------------------------------------
+        # Accessors
+
+        # TODO: find uses of :entries & replace them with standardized string value method here
+        attr_reader :tag, :label, :entries, :order
+
+        # ------------------------------------------------------------
+        # Initializers
+
+        def initialize(tag:, label:, entries:, order:)
+          raise ArgumentError, 'Entries cannot be empty' if entries.empty?
+
+          @tag = tag
+          @label = label
+          @order = order
+          @entries = entries
+        end
+
+        # ------------------------------------------------------------
+        # Public methods
+
+        def includes_link?(link_body)
+          entries.any? do |entry|
+            entry.is_a?(Link) && entry.body == link_body
+          end
+        end
+
+        def as_string
+          entries.join(' ').gsub(/[[:space:]]+/, ' ')
+        end
+
+        # ------------------------------
+        # Object overrides
+
+        def to_s
+          StringIO.new.tap do |out|
+            out << "#{label} (#{tag}): "
+            out << entries.join(' ')
+          end.string
+        end
+
+        # @param other [Value] the Value to compare
+        def <=>(other)
+          compare_by_attributes(self, other, :order, :tag, :entries, :label)
+        end
+
+        # ------------------------------------------------------------
+        # Class methods
+
+        class << self
+          include AV::Util
+          include BerkeleyLibrary::Util::URIs
+
+          def value_for(field, subfield_groups)
+            return if subfield_groups.empty?
+            return if (all_entries = entries_from_groups(subfield_groups, field.subfields_separator)).empty?
+
+            Value.new(tag: field.tag, label: field.label, entries: all_entries, order: field.order)
+          end
+
+          def link_value(field, link)
+            Value.new(tag: field.tag, label: field.label, order: field.order, entries: [link])
+          end
+
+          private
+
+          def entries_from_groups(subfield_groups, separator)
+            subfield_groups.each_with_object([]) do |sg, entries|
+              entries.concat(entries_from_group(sg, separator))
+            end
+          end
+
+          def entries_from_group(subfield_group, separator)
+            [].tap do |entries|
+              link = extract_link(subfield_group)
+              entries << link if link
+
+              subfield_values = subfield_group.values.map { |sf| tidy_value(sf.value) }
+              entries << subfield_values.join(separator) unless subfield_values.empty?
+            end
+          end
+
+          def extract_link(subfield_group)
+            return unless (url_sf = subfield_group.delete(URL_CODE))
+
+            url = url_sf.value
+            body = link_body_from(subfield_group) || url
+            AV::Metadata::Link.new(url:, body:)
+          end
+
+          def link_body_from(subfield_group)
+            body_sf = BODY_CODES.lazy.filter_map { |code| subfield_group.delete(code) }.first
+            return unless body_sf
+
+            body_value = tidy_value(body_sf.value)
+            body_value unless body_value.empty?
+          end
+
+        end
+
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/metadata.rb

@@ -0,0 +1,103 @@
+require 'berkeley_library/av/constants'
+require 'berkeley_library/av/metadata/fields'
+require 'berkeley_library/av/metadata/source'
+require 'berkeley_library/av/restrictions'
+
+module BerkeleyLibrary
+  module AV
+    class Metadata
+      include AV::Constants
+
+      attr_reader :record_id, :source
+
+      # TODO: can we stop passing in record ID / stop lazy-loading MARC?
+      def initialize(record_id:, source:, marc_record: nil)
+        @record_id = record_id
+        @source = source
+        @marc_record = marc_record
+      end
+
+      def bib_number
+        return @bib_number if instance_variable_defined?(:@bib_number)
+
+        @bib_number = source.find_bib_number(self)
+      end
+
+      def tind_id
+        id_001 if source == Source::TIND
+      end
+
+      def alma_id
+        id_001 if source == Source::ALMA
+      end
+
+      def marc_record
+        @marc_record ||= source.record_for(record_id)
+      end
+
+      def values_by_field
+        @values_by_field ||= Fields.default_values_from(marc_record).tap { |values| ensure_catalog_link(values) }
+      end
+
+      def each_value(&)
+        values_by_field.each_value(&)
+      end
+
+      def title
+        @title ||= (title_value = values_by_field[Fields::TITLE]) ? title_value.entries.first : UNKNOWN_TITLE
+      end
+
+      def description
+        @description ||= (desc_value = values_by_field[Fields::DESCRIPTION]) ? desc_value.as_string : ''
+      end
+
+      def calnet_or_ip?
+        restrictions.calnet_or_ip?
+      end
+
+      def calnet_only?
+        restrictions.calnet_only?
+      end
+
+      def display_uri
+        @display_uri ||= source.display_uri_for(self)
+      end
+
+      class << self
+        def for_record(record_id:)
+          source = Source.for_record_id(record_id)
+          raise AV::RecordNotFound, "Unable to determine metadata source for record ID: #{record_id.inspect}" unless source
+
+          Metadata.new(record_id:, source:)
+        end
+      end
+
+      private
+
+      def restrictions
+        @restrictions ||= Restrictions.new(marc_record)
+      end
+
+      def id_001
+        return @id_001 if instance_variable_defined?(:@id_001)
+        return (@id_001 = nil) unless (cf_001 = marc_record['001'])
+
+        @id_001 = RecordId.ensure_record_id(cf_001.value)
+      end
+
+      def ensure_catalog_link(values_by_field)
+        catalog_value = values_by_field[Fields::CATALOG_LINK]
+        return if catalog_value && catalog_value.includes_link?(source.catalog_link_text)
+
+        catalog_link = Link.new(url: display_uri.to_s, body: source.catalog_link_text)
+
+        if catalog_value
+          catalog_value.entries << catalog_link
+        else
+          values_by_field[Fields::CATALOG_LINK] = Value.link_value(Fields::CATALOG_LINK, catalog_link)
+        end
+      end
+
+    end
+  end
+end

data/lib/berkeley_library/av/record.rb

@@ -0,0 +1,86 @@
+require 'berkeley_library/util'
+
+require 'berkeley_library/av/track'
+require 'berkeley_library/av/metadata'
+require 'berkeley_library/av/metadata/source'
+
+module BerkeleyLibrary
+  module AV
+    class Record
+      include BerkeleyLibrary::Util
+
+      attr_reader :collection, :tracks, :metadata
+
+      # TODO: stop passing in track list & just get it from metadata & collection
+      def initialize(collection:, tracks:, metadata:)
+        @collection = collection
+        @tracks = tracks.sort
+        @metadata = metadata
+      end
+
+      def title
+        metadata.title
+      end
+
+      def bib_number
+        metadata.bib_number
+      end
+
+      def tind_id
+        metadata.tind_id
+      end
+
+      def record_id
+        metadata.record_id
+      end
+
+      def calnet_or_ip?
+        metadata.calnet_or_ip?
+      end
+
+      def calnet_only?
+        metadata.calnet_only?
+      end
+
+      def type_label
+        @type_label ||= begin
+          file_types = Set.new(tracks.map(&:file_type)).to_a.sort
+          file_types = AV::Types::FileType.to_a if file_types.empty?
+
+          file_types.map(&:label).join(' / ')
+        end
+      end
+
+      def player_uri
+        @player_uri ||= URIs.append(AV::Config.avplayer_base_uri, collection, record_id)
+      end
+
+      def display_uri
+        metadata.display_uri
+      end
+
+      def description
+        metadata.description
+      end
+
+      class << self
+        # Loads the metadata for the specified record and creates a record object from it.
+        #
+        # Note that for TIND records the record ID is *not* the TIND internal ID
+        # (MARC field 001) but rather the ID assigned by the UC Berkeley Library
+        # (MARC field 035).
+        #
+        # @param collection [String] The collection name (Wowza application id).
+        # @param record_id [String] The record ID.
+        def from_metadata(collection:, record_id:)
+          metadata = Metadata.for_record(record_id:)
+          Record.new(
+            collection:,
+            metadata:,
+            tracks: Track.tracks_from(metadata.marc_record, collection:)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/record_id.rb

@@ -0,0 +1,121 @@
+require 'typesafe_enum'
+require 'berkeley_library/av/constants'
+
+# TODO: use berkeley_library/alma to replace as much of this as possible
+module BerkeleyLibrary
+  module AV
+    class RecordId
+      include AV::Util
+      include Comparable
+
+      # ------------------------------------------------------------
+      # Fields
+
+      attr_reader :id, :type
+
+      # ------------------------------------------------------------
+      # Initializer
+
+      def initialize(id)
+        @id = id.to_s
+        @type = Type.for_id(@id)
+      end
+
+      # ------------------------------------------------------------
+      # Class methods
+
+      class << self
+        include AV::Constants
+
+        def ensure_record_id(record_id)
+          return record_id if record_id.is_a?(RecordId)
+
+          RecordId.new(record_id)
+        end
+
+        def ensure_check_digit(bib_number)
+          digit_str, check_str = split_bib(bib_number)
+
+          digits = digit_str.chars.map(&:to_i)
+          check_digit = calculate_check_digit(digits)
+
+          return "b#{digit_str}#{check_digit}" if check_str.nil? || check_str == 'a'
+          return bib_number if check_str == check_digit
+
+          raise ArgumentError, "#{bib_number} check digit invalid: expected #{check_digit}, got #{check_str}"
+        end
+
+        def strip_check_digit(bib_number)
+          digit_str, = split_bib(bib_number)
+          "b#{digit_str}"
+        end
+
+        private
+
+        def split_bib(bib_number)
+          raise ArgumentError, "Not a Millennium bib number: #{bib_number.inspect}" unless (md = MILLENNIUM_RECORD_RE.match(bib_number.to_s))
+
+          %i[digits check].map { |part| md[part] }
+        end
+
+        def calculate_check_digit(digits)
+          raise ArgumentError, "Not an 8-digit array : #{digits.inspect}" unless digits.is_a?(Array) && digits.size == 8
+
+          # From: http://liwong.blogspot.com/2018/04/recipe-computing-millennium-checkdigit.html
+          mod = digits.reverse.each_with_index.inject(0) { |sum, (v, i)| sum + (v * (i + 2)) } % 11
+          mod == 10 ? 'x' : mod.to_s
+        end
+      end
+
+      # ------------------------------------------------------------
+      # Comparable
+
+      def <=>(other)
+        compare_by_attributes(self, other, :id, :type)
+      end
+
+      # ------------------------------------------------------------
+      # Object overrides
+
+      def hash
+        [id, type].hash
+      end
+
+      def to_s
+        id
+      end
+
+      def inspect
+        "#{self.class}(#{id} [#{type}])@#{object_id}"
+      end
+
+      # ------------------------------------------------------------
+      # Helper classes
+
+      class Type < TypesafeEnum::Base
+        new :ALMA
+        new :MILLENNIUM
+        new :OCLC
+        new :TIND
+
+        def to_s
+          key.to_s
+        end
+
+        class << self
+          include AV::Constants
+
+          def for_id(id)
+            return unless id
+            return id.type if id.is_a?(RecordId)
+            return Type::ALMA if ALMA_RECORD_RE =~ id
+            return Type::MILLENNIUM if MILLENNIUM_RECORD_RE =~ id
+            return Type::OCLC if OCLC_RECORD_RE =~ id
+
+            Type::TIND
+          end
+        end
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/record_not_found.rb

@@ -0,0 +1,7 @@
+module BerkeleyLibrary
+  module AV
+    class RecordNotFound < RuntimeError
+
+    end
+  end
+end

data/lib/berkeley_library/av/restrictions.rb

@@ -0,0 +1,36 @@
+module BerkeleyLibrary
+  module AV
+    class Restrictions
+
+      # TODO: remove 85642$y and 95640$z once we confirm all records have 998$r
+      SUBFIELD_VALUE_SPECS = %w[998$r/#-# 856$y/#-#{^1=\4}{^2=\2} 956$z/#-#{^1=\4}{^2=\0}].freeze
+
+      RE_CALNET_ONLY = /CalNet/i
+      RE_CALNET_OR_IP = /UCB access|UCB only/i
+
+      attr_reader :marc_record
+
+      def initialize(marc_record)
+        @marc_record = marc_record
+      end
+
+      def calnet_only?
+        @calnet ||= any_field_value_matches?(RE_CALNET_ONLY)
+      end
+
+      def calnet_or_ip?
+        @ucb_ip ||= any_field_value_matches?(RE_CALNET_OR_IP)
+      end
+
+      private
+
+      def any_field_value_matches?(re)
+        field_values.any? { |v| re =~ v }
+      end
+
+      def field_values
+        @field_values ||= SUBFIELD_VALUE_SPECS.flat_map { |spec| MARC::Spec.find(spec, marc_record) }
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/track.rb

@@ -0,0 +1,132 @@
+require 'berkeley_library/av/constants'
+require 'berkeley_library/av/types/duration'
+require 'berkeley_library/av/types/file_type'
+require 'berkeley_library/av/marc/util'
+require 'marc'
+
+module BerkeleyLibrary
+  module AV
+    class Track
+      include Comparable
+      include AV::Constants
+      include AV::Util
+
+      attr_reader :sort_order, :title, :path, :duration, :file_type
+
+      def initialize(sort_order:, path:, title: nil, duration: nil)
+        @sort_order = sort_order
+        @title = title
+        @path = path
+        @duration = duration_or_nil(duration)
+        @file_type = AV::Types::FileType.for_path(path)
+      end
+
+      def <=>(other)
+        compare_by_attributes(self, other, :sort_order, :title, :duration, :path)
+      end
+
+      def to_s
+        ''.tap do |s|
+          s << "#{sort_order}: " if sort_order
+          s << path
+          s << " #{title.inspect}" if title
+          s << " (#{duration})" if duration
+        end
+      end
+
+      def inspect
+        "\#<#{self.class.name} #{self}>"
+      end
+
+      # @return [Array<MARC::Subfield>]
+      def to_marc_subfields
+        [].tap do |subfields|
+          subfields << MARC::Subfield.new(SUBFIELD_CODE_DURATION, duration.to_s) if duration
+          subfields << MARC::Subfield.new(SUBFIELD_CODE_TITLE, title) if title
+          subfields << MARC::Subfield.new(SUBFIELD_CODE_PATH, path)
+        end
+      end
+
+      private
+
+      def duration_or_nil(duration)
+        return duration if duration.is_a?(AV::Types::Duration)
+
+        AV::Types::Duration.from_string(duration)
+      end
+
+      class << self
+        include AV::Constants
+        include AV::Marc::Util
+
+        LABELS = {
+          SUBFIELD_CODE_DURATION => 'duration',
+          SUBFIELD_CODE_TITLE => 'title',
+          SUBFIELD_CODE_PATH => 'path'
+        }.freeze
+
+        # Note that if multiple tracks are encoded in the same 998 field, the
+        # subfields **must** be in the order :a, :t, :g (duration, title, path),
+        # as documented in {https://docs.google.com/document/d/1gRWsaSoerSvadNlYR-zbYOjgj0geLxV41bBC0rm5nHE/edit
+        # "How to add media to the AV System"}.
+        #
+        # @param marc_record [MARC::Record] the MARC record
+        # @param collection [String] the collection
+        def tracks_from(marc_record, collection:)
+          track_fields = marc_record.fields(TAG_TRACK_FIELD)
+          track_fields.each_with_object([]) do |df, all_tracks|
+            value_groups = group_values(df.subfields)
+            value_groups.each do |group|
+              all_tracks << from_value_group(group, collection:, sort_order: all_tracks.size)
+            end
+          end
+        end
+
+        private
+
+        def group_values(subfields)
+          filtered = subfields.select { |sf| SUBFIELD_CODES_TRACKS.include?(sf.code.to_sym) }
+          group_subfields(filtered).map { |sfg| to_value_group(sfg) }
+        end
+
+        def group_subfields(subfields)
+          single_track = subfields.lazy.select { |sf| sf.code.to_sym == SUBFIELD_CODE_PATH }.one?
+          return [group_together(subfields)] if single_track
+
+          group_on_paths(subfields)
+        end
+
+        def group_together(subfields)
+          subfields.each_with_object({}) { |sf, grp| grp[sf.code.to_sym] = sf }
+        end
+
+        def group_on_paths(subfields)
+          current_group = {}
+          subfields.each_with_object([]) do |subfield, groups|
+            code_sym = subfield.code.to_sym
+
+            current_group[code_sym] = subfield
+            if code_sym == SUBFIELD_CODE_PATH
+              groups << current_group
+              current_group = {}
+            end
+          end
+        end
+
+        def to_value_group(subfield_group)
+          subfield_group.transform_values { |sf| tidy_value(sf.value) }
+        end
+
+        def from_value_group(group, collection:, sort_order:)
+          Track.new(
+            sort_order:,
+            title: group[SUBFIELD_CODE_TITLE],
+            path: "#{collection}/#{group[SUBFIELD_CODE_PATH]}",
+            duration: group[SUBFIELD_CODE_DURATION]
+          )
+        end
+
+      end
+    end
+  end
+end

data/lib/berkeley_library/av/types/duration.rb

@@ -0,0 +1,67 @@
+module BerkeleyLibrary
+  module AV
+    module Types
+      class Duration
+        include Comparable
+
+        DURATION_RE = /^([0-9]{1,2})?:?([0-9]{2}):?([0-9]{2})$/
+
+        attr_reader :total_seconds
+
+        def initialize(hours: 0, minutes: 0, seconds: 0)
+          @total_seconds = (3600 * hours) + (60 * minutes) + seconds
+        end
+
+        def hours
+          @hours ||= (total_seconds / 3600).floor
+        end
+
+        def minutes
+          remainder = total_seconds % 3600
+          (remainder / 60).floor
+        end
+
+        def seconds
+          remainder = total_seconds % 60
+          remainder.floor
+        end
+
+        def to_s
+          format('%02d:%02d:%02d', hours, minutes, seconds)
+        end
+
+        def <=>(other)
+          return 0 if equal?(other)
+          return unless other
+          return unless other.respond_to?(:total_seconds)
+
+          total_seconds <=> other.total_seconds
+        end
+
+        class << self
+          # @return [Duration] the duration, or nil
+          def from_string(s)
+            return unless s
+
+            value = clean_value(s)
+            return unless (md = DURATION_RE.match(value))
+
+            Duration.new(
+              hours: md[1].to_i,
+              minutes: md[2].to_i,
+              seconds: md[3].to_i
+            )
+          end
+
+          private
+
+          def clean_value(value)
+            raise ArgumentError, "Not a string: #{value.inspect}" unless value.is_a?(String)
+
+            value.gsub(/[[:space:]]/, '')
+          end
+        end
+      end
+    end
+  end
+end