relaton-render 1.4.0.pre.alpha.3 → 3.0.0.pre.alpha.1

data/lib/relaton/render/parse/parse.rb

@@ -0,0 +1,152 @@
+require "nokogiri"
+require "twitter_cldr"
+require_relative "parse_contributors"
+require_relative "parse_extract"
+require_relative "parse_id"
+
+module Relaton
+  module Render
+    class Parse
+      def initialize(options)
+        @lang = options[:lang] || "en"
+        @script = options[:script] || "Latn"
+        @i18n = options[:i18n]
+      end
+
+      def extract(doc)
+        host = host(doc)
+        ret = simple_xml2hash(doc).merge(simple_or_host_xml2hash(doc, host))
+          .merge(host_xml2hash(host))
+          .merge(series_xml2hash(doc, host))
+        ret
+        #i18n(ret)
+      end
+
+      def simple_xml2hash(doc)
+        creators, role = creatornames(doc)
+        { type: type(doc), title: title(doc), extent_raw: extent(doc),
+          size_raw: size(doc), uri_raw: uri(doc), doi: doi(doc),
+          authoritative_identifier: authoritative_identifier(doc),
+          other_identifier_raw: other_identifier(doc), biblio_tag: biblio_tag(doc),
+          status_raw: status(doc), creators: creators, role_raw: role,
+          language: language(doc), script: script(doc), locale: locale(doc) }
+      end
+
+      def simple_or_host_xml2hash(doc, host)
+        { edition_raw: edition(doc, host), edition_num: edition_num(doc, host),
+          medium_raw: medium(doc, host), draft_raw: draft(doc, host),
+          place_raw: place(doc, host), publisher_raw: publisher(doc, host),
+          publisher_abbrev_raw: publisher_abbrev(doc, host),
+          authorizer_raw: authorizer(doc, host),
+          distributor_raw: distributor(doc, host),
+          access_location: access_location(doc, host),
+          date: date(doc, host), date_updated: date_updated(doc, host),
+          date_accessed: date_accessed(doc, host) }
+      end
+
+      def host_xml2hash(host)
+        creators, role = creatornames(host)
+        { host_creators: creators, host_role_raw: role,
+          host_title: title(host) }
+      end
+
+      def series_xml2hash(doc, host)
+        series = series(doc)
+        host and series ||= series(host)
+        series_xml2hash1(series, doc)
+      end
+
+      def series_xml2hash1(series, doc)
+        series or return {}
+        ret = { series_formatted: series_formatted(series, doc),
+                series_title: series_title(series, doc),
+                series_abbr: series_abbr(series, doc),
+                series_run: series_run(series, doc),
+                series_num: series_num(series, doc),
+                series_partnumber: series_partnumber(series, doc),
+                series_place: series_place(series, doc),
+                series_org: series_org(series, doc),
+                series_dates: series_dates(series, doc) }
+        ret.each do |k, v|
+          %i(series_num series_dates).include?(k) and next
+          ret[k] = esc(v)
+        end
+        ret
+      end
+
+      #KILL
+      def other_identifier_i18n(hash)
+           #ret << "#{type}: #{esc id.id}"
+        hash[:other_identifier]&.map! do |i|
+          i.include?("<esc>") ? @i18n.select(hash).l10n(i) : i
+        end
+      end
+
+      ALLOWED_INLINE_TAGS = %w[
+        em eref strong stem sub sup tt underline keyword ruby
+        strike smallcap xref br link hr pagebreak bookmark
+        image index index-xref concept add del span erefstack
+        date fn
+      ].freeze
+
+      private
+
+      def blank?(text)
+        text.nil? || text.empty?
+      end
+
+      def esc(text)
+        blank?(text) and return text
+        "<esc>#{text}</esc>"
+      end
+
+      # Strip any tag not in ALLOWED_INLINE_TAGS, in both literal (<tag>) and
+      # entity-encoded (&lt;tag&gt;) forms. Used to defend Liquid template
+      # output against embedded structural markup (most commonly <title>) in
+      # bibliographic text fields, where relaton-bib may surface either form
+      # depending on lutaml-model serialisation behaviour.
+      #
+      # Authors embed inline markup either literally (<em>foo</em>) or
+      # entity-encoded (&lt;em&gt;foo&lt;/em&gt;); both are intended as
+      # markup, and downstream template rendering decodes entities anyway
+      # (see HTMLEntities.decode in template.rb), so we normalise the
+      # encoded form to literal up front and let a single Nokogiri-fragment
+      # walk handle both. Elements whose name is in the allow-list are
+      # preserved verbatim with their entire subtree, so wrappers that
+      # legitimately carry block content (notably <fn><p>…</p></fn>)
+      # round-trip intact rather than being shredded one tag at a time.
+      # Disallowed elements are unwrapped (tag dropped, children kept),
+      # recursing first so allowed wrappers nested inside disallowed
+      # wrappers still survive. Nokogiri re-escapes any genuine `<` left in
+      # text positions on serialisation, so plain prose like "5 < 10" is
+      # preserved correctly.
+      def sanitise_inline_markup(str)
+        blank?(str) and return str
+        normalised = str.gsub("&lt;", "<").gsub("&gt;", ">")
+        frag = Nokogiri::XML.fragment(normalised)
+        unwrap_disallowed(frag)
+        save_opts = Nokogiri::XML::Node::SaveOptions::AS_XML |
+                    Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+        frag.to_xml(encoding: "UTF-8", save_with: save_opts)
+      end
+
+      def unwrap_disallowed(node)
+        node.children.to_a.each do |child|
+          next unless child.element?
+          next if ALLOWED_INLINE_TAGS.include?(child.name)
+
+          unwrap_disallowed(child)
+          child.replace(child.children)
+        end
+      end
+
+      def wrap_in_esc(obj)
+        case obj
+        when String then esc(obj)
+        when Array then obj.map { |e| wrap_in_esc(e) }
+        else obj
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/parse/parse_contributors.rb

@@ -0,0 +1,184 @@
+module Relaton
+  module Render
+    class Parse
+      def content(node)
+        node.nil? and return node
+        node.is_a?(String) and
+          return sanitise_inline_markup(node.strip)
+            .gsub(/>\n\s*</, "><").gsub(/\n\s*/, " ")
+        node.content.is_a?(Array) and return node.content.map { |x| content(x) }
+        ret = sanitise_inline_markup(node.content.strip)
+        # safeguard against indented XML
+        ret.gsub(/>\n\s*</, "><").gsub(/\n\s*/, " ")
+      end
+
+      def extract_orgname(org)
+        content(org.name&.first)
+      end
+
+      def extract_personname(person)
+        surname = person.name.surname || person.name.completename
+        given, middle, initials = given_and_middle_name(person)
+        { surname: wrap_in_esc(content(surname)),
+          given: given,
+          middle: middle,
+          initials: initials }
+      end
+
+      def given_and_middle_name(person)
+        forenames = forenames_parse(person)
+        initials = extract_initials(person)
+        forenames.empty? and initials.empty? and return [nil, nil, nil]
+        initials.empty? and initials = initials_from_forenames(forenames)
+        [forenames.first, forenames[1..-1],
+         wrap_in_esc(Array(initials))]
+      end
+
+      def extract_initials(person)
+        initials = content(person.name.formatted_initials)&.sub(/(.)\.?$/, "\\1.")
+          &.split /(?<=\.) /
+        initials ||= person.name.forename.map(&:initial)
+          .compact.map { |x| x.sub(/(.)\.?$/, "\\1.") }
+        initials
+      end
+
+      def forenames_parse(person)
+        person.name.forename.map do |x|
+          x.content.nil? || x.content.empty? ? esc("#{x.initial}.") : content(x)
+        end
+      end
+
+      # de S. => one initial, M.-J. => one initial
+      def initials_parse(person)
+        i = content(person.name.formatted_initials) or
+          return person.name.forename.map(&:initial)
+              .compact.map { |x| x.sub(/(.)\.?$/, "\\1.") }
+
+        i.sub(/(.)\.?$/, "\\1.")
+          .scan(/.+?\.(?=(?:$|\s|\p{Alpha}))/).map(&:strip)
+      end
+
+      def initials_from_forenames(forenames)
+        forenames.map(&:split).flatten.map { |x| "#{x[0]}." }
+      end
+
+      def extractname(contributor)
+        org = contributor.organization
+        person = contributor.person
+        return { nonpersonal: extract_orgname(org) } if org
+        return extract_personname(person) if person
+
+        nil
+      end
+
+      def contributor_role(contributors)
+        contributors.length.positive? or return nil
+        role = contributors[0].role.first
+        desc = Array(role&.description).map(&:content).join("\n")
+        type = role&.type
+        desc.empty? ? type : desc
+      end
+
+      def creatornames(doc)
+        cr = creatornames1(doc)
+        cr.empty? and return [nil, nil]
+        [cr.map { |x| extractname(x) }, contributor_role(cr)]
+      end
+
+      def creatornames_roles_allowed
+        %w(author performer adapter translator editor distributor authorizer)
+      end
+
+      def creatornames1(doc)
+        cr = []
+        doc.nil? and return []
+        creatornames_roles_allowed.each do |r|
+          add = pick_contributor(doc, r)
+          add.nil? and next
+          cr = add and break
+        end
+        cr.nil? and cr = Array(doc.contributor)
+        cr
+      end
+
+      def datepick(date)
+        date.nil? and return nil
+        at = date.at
+        from = date.from
+        to = date.to
+        at and return { on: at.to_s }
+        from and return { from: from.to_s, to: to&.to_s }
+        nil
+      end
+
+      def date1(date)
+        %w(published issued circulated).each do |t|
+          ret = date.detect { |x| x.type == t } and
+            return ret
+        end
+        date.reject { |x| x.type == "accessed" }.first
+      end
+
+      # year-only
+      def date(doc, host)
+        ret = date1(Array(doc.date))
+        host and ret ||= date1(Array(host.date))
+        datepick(ret)&.transform_values do |v|
+          v&.sub(/-.*$/, "")
+        end
+      end
+
+      def date_updated(doc, host)
+        ret = Array(doc.date).detect { |x| x.type == "updated" }
+        host and ret ||= Array(host.date).detect { |x| x.type == "updated" }
+        datepick(ret)
+      end
+
+      def date_accessed(doc, host)
+        ret = Array(doc.date).detect { |x| x.type == "accessed" }
+        host and ret ||= Array(host.date).detect { |x| x.type == "accessed" }
+        datepick(ret)
+      end
+
+      def publisher(doc, host)
+        x = pick_contributor(doc, "publisher")
+        host and x ||= pick_contributor(host, "publisher")
+        x.nil? and return nil
+        x.map { |c| extractname(c) }
+      end
+
+      def publisher_abbrev(doc, host)
+        x = pick_contributor(doc, "publisher")
+        host and x ||= pick_contributor(host, "publisher")
+        x.nil? and return nil
+        x.map do |c|
+          content(c.organization.abbreviation) ||
+            content(c.organization.name.first)
+        end
+      end
+
+      def distributor(doc, host)
+        x = pick_contributor(doc, "distributor")
+        host and x ||= pick_contributor(host, "distributor")
+        x.nil? and return nil
+        x.map { |c| extractname(c) }
+      end
+
+      def authorizer(doc, host)
+        x = pick_contributor(doc, "authorizer") ||
+          pick_contributor(doc, "publisher")
+        host and x ||= pick_contributor(host, "authorizer") ||
+          pick_contributor(host, "publisher")
+        x.nil? and return nil
+        x.map { |c| extractname(c) }
+      end
+
+      def pick_contributor(doc, role)
+        ret = Array(doc.contributor).select do |c|
+          Array(c.role).any? { |r| r.type == role }
+        end
+        ret.empty? ? nil : ret
+      end
+    end
+  end
+end

data/lib/relaton/render/parse/parse_extract.rb

@@ -0,0 +1,200 @@
+module Relaton
+  module Render
+    class Parse
+      def host(doc)
+        doc.relation&.detect { |r| r.type == "includedIn" }&.bibitem
+      end
+
+      # TODO : first is naive choice
+      def title(doc)
+        doc.nil? || doc.title.nil? || doc.title.empty? and return nil
+        t = Array(doc.title).select { |x| x.language == @lang }
+        t.empty? and t = Array(doc.title)
+        t1 = t.select { |x| x.type == "main" }
+        t1.empty? and t1 = t
+        t1.first or return
+        esc(content(t1.first))
+      end
+
+      def medium(doc, host)
+        x = doc.medium || host&.medium or return nil
+        %w(content genre form carrier size scale).each_with_object({}) do |i, m|
+          m[i] = x.send i
+        end.compact
+      end
+
+      def size(doc)
+        x = doc.size or return nil
+        x.value.each_with_object({}) do |v, m|
+          m[v.type] ||= []
+          m[v.type] << v.content
+        end
+      end
+
+      def edition(doc, host)
+        ret = content(doc.edition || host&.edition)
+        ret &&= esc(ret)
+        ret
+      end
+
+      def edition_num(doc, host)
+        doc.edition&.number || host&.edition&.number
+      end
+
+      def place(doc, host)
+        x = Array(doc.place)
+        x.empty? && host and x = Array(host.place)
+        x.empty? and return x
+        x.map { |p| place1(p) }
+      end
+
+      def place1(place)
+        c = place.city
+        r = place.region
+        n = place.country
+        c.nil? && r.empty? && n.empty? and return place.formatted_place
+        [c, *r.map(&:content), *n.map(&:content)].compact.join(", ")
+      end
+
+      def series(doc)
+        doc.series&.detect { |s| s.type == "main" } ||
+          doc.series&.detect { |s| s.type.nil? } ||
+          doc.series&.first
+      end
+
+      def series_title(series, _doc)
+        series.nil? and return nil
+        t = Array(series.title).select { |x| x.language == @lang }
+        t.empty? and t = Array(series.title)
+        t1 = t.select { |x| x.type == "main" }
+        t1.empty? and t1 = t
+        t1.first.nil? and return nil
+        content(t1.first)
+      end
+
+      def series_formatted(series, _doc)
+        content(series.formattedref)
+      end
+
+      def series_abbr(series, _doc)
+        content(series.abbreviation)
+      end
+
+      def series_num(series, _doc)
+        series.number&.strip
+      end
+
+      def series_partnumber(series, _doc)
+        series.partnumber
+      end
+
+      def series_run(series, _doc)
+        series.run
+      end
+
+      def series_org(series, _doc)
+        series.organization
+      end
+
+      def series_place(series, _doc)
+        p = series.place or return nil
+        place1(p)
+      end
+
+      def series_dates(series, _doc)
+        f = series.from
+        t = series.to
+        f || t or return nil
+        "#{f}–#{t}"
+      end
+
+      def access_location(doc, host)
+        x = doc.accesslocation || host&.accesslocation or
+          return nil
+        Array(x).first
+      end
+
+      def included(type)
+        ["article", "inbook", "incollection", "inproceedings"].include? type
+      end
+
+      def type(doc)
+        type = doc.type and return type
+        doc.relation&.any? { |r| r.type == "includedIn" } and return "inbook"
+        "book"
+      end
+
+      def language(doc)
+        doc.language&.first || @lang
+      end
+
+      def script(doc)
+        doc.script&.first || @script
+      end
+
+      def locale(doc)
+        # TODO not yet implemented in relaton-bib
+        # doc.locale&.first
+      end
+
+      def extent1(localities)
+        localities.each_with_object({}) do |l, ret|
+          ret[(l.type || "page").to_sym] = {
+            from: localized_string_or_text(l.reference_from),
+            to: localized_string_or_text(l.reference_to),
+          }
+        end
+      end
+
+      def localized_string_or_text(str)
+        case str
+        when Relaton::Bib::LocalizedString then content(str)
+        when String then str
+        end
+      end
+
+      def extent(doc)
+        Array(doc.extent).each_with_object([]) do |e, acc|
+          case e
+          when Relaton::Bib::Extent, Relaton::Bib::LocalityStack
+            if e.locality.any?
+              a = e.locality.each_with_object([]) do |e1, m|
+                if e1.is_a?(Relaton::Bib::LocalityStack)
+                  m << extent1(e1.locality)
+                else
+                  m.empty? and m << {}
+                  m[-1].merge!(extent1(Array(e1)))
+                end
+              end
+              acc << a
+            else
+              Array(e.locality_stack).each do |stack|
+                a = stack.locality.each_with_object([{}]) do |e1, m|
+                  m[-1].merge!(extent1(Array(e1)))
+                end
+                acc << a
+              end
+            end
+          when Relaton::Bib::Locality
+            acc << extent1(Array(e))
+          end
+        end
+      end
+
+      def draft(doc, host)
+        { iteration: iter_ordinal(doc) || iter_ordinal(host),
+          status: status(doc) || status(host) }
+      end
+
+      def iter_ordinal(doc)
+        iter = doc&.status&.iteration or return nil
+        iter
+      end
+
+      def status(doc)
+        v = doc&.status&.stage&.content
+        #@i18n.get.dig("stage", v) || v
+      end
+    end
+  end
+end

data/lib/relaton/render/parse/parse_id.rb

@@ -0,0 +1,128 @@
+module Relaton
+  module Render
+    class Parse
+      # filter applied across full list of auth_id
+      def auth_id_filter(ids = [])
+        id_scope_filter(ids)
+      end
+
+      def id_scope_filter(ids)
+        ids.detect(&:scope) or return ids
+        id_sort_by_scope(ids).each_with_object([]) do |(k, v), m|
+          case k
+          when "IEEE"
+            f = id_extract_by_scope(v, "trademark")
+            f.empty? and f = id_extract_by_scope(v, nil)
+            m << f
+          else m << id_extract_by_scope(v, nil)
+          end
+        end.flatten
+      end
+
+      def id_sort_by_scope(ids)
+        ids.each_with_object({}) do |i, m|
+          m[i.type] ||= {}
+          m[i.type][i.scope] ||= []
+          m[i.type][i.scope] << i
+        end
+      end
+
+      def id_extract_by_scope(idents, key)
+        if idents.key?(key)
+          idents[key]
+        else []
+        end
+      end
+
+      # list of successive filters on individual auth_id instances
+      def auth_id_allow
+        [->(x) { x.language == @lang && x.primary },
+         ->(x) { x.primary },
+         ->(x) { x.language == @lang },
+         ->(_x) { true }]
+      end
+
+      def authoritative_identifier(doc)
+        out = []
+        [auth_id_filter(Array(doc.docidentifier)), Array(doc.docidentifier)].each do |a|
+          out = authoritative_identifier_select(a)
+          out.empty? or break
+        end
+        # prevent l10n of identifier contents
+        out.map(&:content).map { |i| esc(i.strip) }
+      end
+
+      def authoritative_identifier_select(idents)
+        out = []
+        auth_id_allow.each do |p|
+          out = idents.select do |x|
+            p.call(x) &&
+              !authoritative_identifier_exclude.include?(id_type_norm(x))
+          end
+          out.empty? or break
+        end
+        out
+      end
+
+      def authoritative_identifier_exclude
+        %w(METANORMA METANORMA-ORDINAL AUTHOR-DATE TITLE URN ISO-REFERENCE) +
+          other_identifier_include
+      end
+
+      def other_identifier(doc)
+        Array(doc.docidentifier).each_with_object([]) do |id, ret|
+          type = id_type_norm(id)
+          other_identifier_include.include? type or next
+          ret << [type, id.content]
+        end
+      end
+
+      def other_identifier_include
+        %w(ISSN ISBN DOI)
+      end
+
+      def doi(doc)
+        out = Array(doc.docidentifier).each_with_object([]) do |id, ret|
+          type = id.type&.sub(/^(DOI)\..*$/i, "\\1") or next
+          type.casecmp("doi").zero? or next
+          ret << id.content
+        end
+        out.empty? ? nil : out.map { |i| esc(i.strip) }
+      end
+
+      def id_type_norm(id)
+        id.type or return nil
+        m = /^(ISBN|ISSN)\./i.match(id.type) or return id.type.upcase
+        m[1].upcase
+      end
+
+      def biblio_tag(doc)
+        ret = Array(doc.docidentifier).detect do |id|
+          id.scope&.downcase == "biblio-tag"
+        end
+        ret&.content
+      end
+
+      def uri(doc)
+        uri = nil
+        %w(citation uri src).each do |t|
+          uri = uri_type_select(doc, t) and break
+        end
+        uri ||= Array(doc.source).detect do |u|
+          u.language == @lang && !u.type&.casecmp("doi")&.zero?
+        end
+        uri ||= Array(doc.source).detect { |u| !u.type&.casecmp("doi")&.zero? }
+        uri or return nil
+        uri.content.to_s.strip
+      end
+
+      def uri_type_select(doc, type)
+        uri = Array(doc.source).detect do |u|
+          u.type&.downcase == type && u.language == @lang
+        end and return uri
+        uri = Array(doc.source).detect { |u| u.type&.downcase == type } and return uri
+        nil
+      end
+    end
+  end
+end