relaton-render 1.3.0 → 1.4.0.pre.alpha.1

data/lib/relaton/render/general/render_classes.rb

@@ -1,132 +0,0 @@
-module Relaton
-  module Render
-    BIBTYPE =
-      %w(article book booklet manual proceedings presentation thesis techreport
-         standard unpublished map electronic_resource audiovisual film video
-         broadcast software graphic_work music patent inbook incollection
-         inproceedings journal website webresource dataset archival social_media
-         alert message conversation misc internal).freeze
-
-    class General
-      singleton_class.send(:attr_reader, :descendants)
-      @descendants = {}
-
-      def self.inherited(subclass) # rubocop:disable Lint/MissingSuper
-        type = subclass.name.downcase.sub(/relaton::render::/, "")
-        General.descendants[type] = subclass
-      end
-
-      def self.subclass(type)
-        # Always look up from the root General class, not from subclasses
-        base = self
-        base = base.superclass while base.superclass != Object && base.superclass.name =~ /Relaton::Render/
-        base.instance_variable_get(:@descendants)&.[](type)
-      end
-    end
-
-    class Book < General
-    end
-
-    class Journal < General
-    end
-
-    class Booklet < General
-    end
-
-    class Manual < General
-    end
-
-    class Proceedings < General
-    end
-
-    class Presentation < General
-    end
-
-    class Thesis < General
-    end
-
-    class Techreport < General
-    end
-
-    class Standard < General
-    end
-
-    class Unpublished < General
-    end
-
-    class Map < General
-    end
-
-    class Electronic_resource < General
-    end
-
-    class Software < Electronic_resource
-    end
-
-    class Webresource < Electronic_resource
-    end
-
-    class Website < Webresource
-    end
-
-    class Dataset < Electronic_resource
-    end
-
-    class Social_media < Electronic_resource
-    end
-
-    class Alert < Social_media
-    end
-
-    class Message < Social_media
-    end
-
-    class Audiovisual < General
-    end
-
-    class Film < Audiovisual
-    end
-
-    class Video < Audiovisual
-    end
-
-    class Broadcast < Audiovisual
-    end
-
-    class Graphic_work < General
-    end
-
-    class Music < General
-    end
-
-    class Patent < General
-    end
-
-    class Hosted < General
-    end
-
-    class Article < Hosted
-    end
-
-    class InBook < Hosted
-    end
-
-    class InCollection < Hosted
-    end
-
-    class InProceedings < Hosted
-    end
-
-    class Archival < General
-    end
-
-    class Conversation < General
-    end
-
-    class Misc < General
-    end
-
-    class Internal < General
-    end
-  end
-end

data/lib/relaton/render/general/uri.rb

@@ -1,57 +0,0 @@
-require "concurrent"
-require "net/http"
-require "uri"
-
-module Relaton
-  module Render
-    class General
-      def url_exist?(url_string)
-        return true # temporarily disabling validation of URIs
-        url = URI.parse(url_string)
-        url.host or return true # allow file URLs
-        res = access_url(url) or return false
-        res.is_a?(Net::HTTPRedirection) and return url_exist?(res["location"])
-        res.code[0] != "4"
-      rescue Errno::ENOENT, SocketError
-        false # false if can't find the server
-      end
-
-      def access_url(url)
-        path = url.path or return false
-        path.empty? and path = "/"
-        url_head(url, path)
-      rescue StandardError => e
-        warn e
-        false
-      end
-
-      def url_head(url, path)
-        ret = nil
-        @semaphore.synchronize { ret = @urlcache[url.to_s] }
-        ret and return ret
-        ret = Net::HTTP.start(url.host, url.port,
-                              read_timeout: 2, open_timeout: 2,
-                              use_ssl: url.scheme == "https") do |http|
-          http.request_head(path)
-        end
-        @semaphore.synchronize { @urlcache[url.to_s] = ret }
-        ret
-      end
-
-      def urls_exist_concurrent(urls)
-        responses = Concurrent::Array.new
-        thread_pool = Concurrent::FixedThreadPool.new(5)
-        urls.each do |u|
-          thread_pool.post { responses << url_exist_async?(u) }
-        end
-        thread_pool.shutdown
-        thread_pool.wait_for_termination
-        responses.each_with_object({}) { |n, m| m[n[:url]] = n[:status] }
-      end
-
-      def url_exist_async?(url_string)
-        { url: url_string, status: url_exist?(url_string) }
-      end
-    end
-  end
-end

data/lib/relaton/render/i18n/i18n.rb

@@ -1,40 +0,0 @@
-module Relaton
-  module Render
-    class I18n
-      # @i18n is a hash of IsoDoc::I18n objects, selected from according to
-      # attributes of the parsed Relaton object
-      def initialize(opt)
-        if opt["i18n_multi"]
-          @i18n = opt["i18n_multi"]
-        elsif opt["i18n"]
-          @i18n = { "" => opt["i18n"] }
-        else
-          raise error "Bad configuration, Relaton::Render::I18n"
-        end
-      end
-
-      # obj is the biblio hash, extracted by Relaton::Render::Fields
-      # There must always be a default selection, for obj = nil,
-      # being the document language setting. If select is applied on obj,
-      # the i18n selected is appropriate to the citation specifically,
-      # and potentially to the field specificaly
-      def select(obj)
-        if obj.nil? then select_default
-        else select_obj(obj)
-        end
-      end
-
-      def select_default
-        @i18n[""]
-      end
-
-      def select_obj(_obj)
-        @i18n[""]
-      end
-
-      def config
-        @i18n
-      end
-    end
-  end
-end

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

@@ -1,152 +0,0 @@
-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

@@ -1,184 +0,0 @@
-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