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

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

@@ -1,316 +0,0 @@
-require_relative "render_classes"
-require_relative "citations"
-require_relative "uri"
-require "yaml"
-require "liquid"
-require "date"
-require "relaton/bib"
-require "metanorma-utils"
-require_relative "../template/template"
-require_relative "../../../isodoc/i18n"
-
-module Relaton
-  module Render
-    class General
-      Hash.include ::Metanorma::Utils::Hash
-      Array.include ::Metanorma::Utils::Array
-
-      attr_reader :template, :journaltemplate, :seriestemplate, :nametemplate,
-                  :authorcitetemplate, :extenttemplate, :sizetemplate,
-                  :citetemplate, :citeshorttemplate, :lang, :script, :i18n,
-                  :edition, :date, :fieldsklass, :dateklass, :config
-
-      def initialize(opt = {})
-        options = init_options(opt)
-        @type = self.class.name.downcase.split("::").last
-        klass_initialize(options)
-        root_initalize(options)
-        render_initialize(options)
-        @parse ||= options["parse"]
-        init_misc
-      end
-
-      def init_options(opt)
-        opt = opt.stringify_all_keys
-        @override_file ||= opt["config"]
-        @config = config_override(read_config)
-        @config.merge(opt)
-      end
-
-      def init_misc
-        @semaphore = Mutex.new
-        @urlcache = {}
-        @url_warned = {}
-      end
-
-      def read_config
-        YAML.load_file(File.join(File.dirname(__FILE__), "config.yml"))
-      end
-
-      def config_override(ret)
-        new = {}
-        @override_file and new = YAML.load_file(@override_file)
-        ret.deep_merge(new)
-      end
-
-      def klass_initialize(options)
-        @nametemplateklass = Relaton::Render::Template::Name
-        @authorcitetemplateklass = Relaton::Render::Template::AuthorCite
-        @citetemplateklass = Relaton::Render::Template::Cite
-        @citeshorttemplateklass = Relaton::Render::Template::Cite
-        @seriestemplateklass = Relaton::Render::Template::Series
-        @extenttemplateklass = Relaton::Render::Template::Extent
-        @sizetemplateklass = Relaton::Render::Template::Size
-        @generaltemplateklass = Relaton::Render::Template::General
-        @fieldsklass = Relaton::Render::Fields
-        @dateklass = Relaton::Render::Date
-        @parseklass = Relaton::Render::Parse
-        @i18nklass = options["i18nklass"] || Relaton::Render::I18n
-        @citeklass = Relaton::Render::Citations
-      end
-
-      def root_initalize(opt)
-        i18n_initialize(opt)
-        @parse = @parseklass.new(lang: @lang, script: @script, i18n: @i18n)
-        @nametemplate = @nametemplateklass
-          .new(template: opt["nametemplate"], i18n: @i18n)
-        @citetemplate,  @citeshorttemplate = citerenderers(opt)
-        @authorcitetemplate = @authorcitetemplateklass
-          &.new(template: opt["authorcitetemplate"], i18n: @i18n)
-        @seriestemplate = @seriestemplateklass
-          .new(template: opt["seriestemplate"], i18n: @i18n)
-        @journaltemplate = @seriestemplateklass
-          .new(template: opt["journaltemplate"], i18n: @i18n)
-        @extenttemplate = extentrenderers(opt)
-        @sizetemplate = sizerenderers(opt)
-      end
-
-      def i18n_initialize(opt)
-        @lang = opt["language"]
-        @script = opt["script"]
-        @locale = opt["locale"]
-        default_i18n = opt["i18n"] ||
-          i18n_klass(language: @lang, script: @script, locale: @locale,
-                     i18nhash: opt["i18nhash"])
-        @i18n = @i18nklass.new(opt.merge({ "i18n" => default_i18n }))
-        i18n_default_strs(opt)
-      end
-
-      # avoid using these, they are document-set not citation-specific
-      def i18n_default_strs(opt)
-        @edition = opt["edition"] || @i18n.select(nil).edition
-        @date = opt["date"] || @i18n.select(nil).get["date_formats"] ||
-          { "month_year" => "yMMMM", "day_month_year" => "to_long_s",
-            "date_time" => "to_long_s" }
-      end
-
-      def render_initialize(opt)
-        case opt["template"]
-        when String
-          @template = @generaltemplateklass
-            .new(template: opt["template"], i18n: @i18n)
-        when Hash
-          @render = renderers(opt)
-        end
-      end
-
-      def renderers(opt)
-        template_hash_fill(opt["template"]).each_with_object({}) do |(k, v), m|
-          @type == "general" || @type == k or next
-          m[k] = self.class.subclass(k)
-            .new(template: v, parse: @parse, i18n_multi: @i18n.config,
-                 language: @lang, script: @script, i18nklass: @i18nklass)
-        end
-      end
-
-      def extentrenderers(opt)
-        @extenttemplateklass
-          .new(template: template_hash_fill(opt["extenttemplate"]), i18n: @i18n)
-      end
-
-      def sizerenderers(opt)
-        @sizetemplateklass
-          .new(template: template_hash_fill(opt["sizetemplate"]), i18n: @i18n)
-      end
-
-      def citerenderers(opt)
-        s = opt["citetemplate"]["short"]
-        r = opt["citetemplate"].reject { |k, _| k == "short" }
-        short = @citetemplateklass
-          &.new(template: template_hash_fill(s), i18n: @i18n)
-        ret = @citetemplateklass
-          &.new(template: r, i18n: @i18n)
-        [ret, short]
-      end
-
-      def default_template
-        "{{creatornames}}. {{title}}. {{disambiguated_date}}."
-      end
-
-      def i18n_klass(language: "en", script: "Latn", locale: nil, i18nhash: nil)
-        ::IsoDoc::RelatonRenderI18n.new(language, script, locale: locale,
-                                                          i18nhash: i18nhash)
-      end
-
-      def render(bib, embedded: false, terminator: true)
-        bib = xml2relaton(bib)
-        f = bib.formattedref and
-          return embedded ? f.content : fmtref(f.content)
-        ret = render1(bib, terminator) or return nil
-        embedded and return ret
-        fmtref(ret)
-      end
-
-      def xml2relaton(bib)
-        bib.is_a?(Relaton::Bib::ItemData) and return bib
-        xml = xml_string2noko(bib)
-        bib = xml.to_xml(encoding: "UTF-8", indent: 0,
-                         save_with: Nokogiri::XML::Node::SaveOptions::AS_XML)
-          .gsub(/ xmlns="[^"]*"/, "")
-        Relaton::Bib::Bibitem.from_xml(bib)
-      end
-
-      def xml_string2noko(bib)
-        case bib
-        when String
-          xml = Nokogiri::XML(bib)
-          xml.errors.empty? or return bib
-          xml.root
-        when Nokogiri::XML::Element
-          bib
-        when Nokogiri::XML::Document
-          bib.root
-        end
-      end
-
-      def fmtref(doc)
-        "<formattedref>#{doc}</formattedref>"
-      end
-
-      def renderer(type)
-        ret = @template || @render[type]&.template or
-          raise "No renderer defined for #{type}"
-        @type == "general" || @type == type or
-          raise "No renderer defined for #{type}"
-        ret
-      end
-
-      # <esc> in field can get capitalised in filters
-      def esc_cleanup(text)
-        text.gsub(/<esc>/i, "<esc>").gsub(/<\/esc>/i, "</esc>")
-      end
-
-      def render1(doc, terminator)
-        obj, str = render_single_bibitem(doc)
-        out = [str] + also_pub_as(doc)
-        ret1 = out.join(@i18n.select(obj).get["punct"]["biblio-field-delimiter"] || ". ")
-        ret = @i18n.select(obj).l10n(esc_cleanup(ret1)
-          .gsub(".</esc>.", ".</esc>").gsub(".. ", ". "))
-        final = @i18n.select(obj).get["punct"]["biblio-terminator"] || "."
-        terminator && !ret.end_with?(final) && !ret.empty? and ret += final
-        ret
-      end
-
-      def also_pub_as(doc)
-        r = Array(doc.relation).select { |x| x.type == "hasRepresentation" }
-        r.map do |x|
-          _, out = render_single_bibitem(x.bibitem)
-          @i18n.select(nil).also_pub_as + out
-        end
-      end
-
-      def render_single_bibitem(doc)
-        data_liquid, r = parse(doc)
-        out = liquid(data_liquid, r)
-        [data_liquid, out]
-      end
-
-      def liquid(data_liquid, renderer)
-        valid_parse(renderer.render(data_liquid, data_liquid))
-      end
-
-      def parse(doc)
-        doc = xml2relaton(doc)
-        r = renderer(doc.type || "misc")
-        data = @parse.extract(doc)
-        enhance_data(data, r.template_raw)
-        data_liquid = @fieldsklass.new(renderer: self)
-          .compound_fields_format(data)
-        [data_liquid, r]
-      end
-
-      def valid_parse(ret)
-        @i18n.select(nil).get["no_date"] == ret and return nil
-        ret&.gsub(/\+\+\+(.+?)\+\+\+/, '\1')
-      end
-
-      # expect array of Relaton objects, in sorted order
-      # enhance_data is skipped here, and is done in batch inside Citations
-      def render_all(bib, type: "author-date")
-        bib = sanitise_citations_input(bib) or return
-        @citeklass.new(type: type, renderer: citation_renderers,
-                       i18n: @i18n, lang: @lang, script: @script)
-          .render(citations1(bib))
-      end
-
-      def citation_renderers
-        { default: self }
-      end
-
-      def sanitise_citations_input(bib)
-        bib.is_a?(Array) and return bib
-        bib.is_a?(String) and return sanitise_citations_input_string(bib)
-      end
-
-      def sanitise_citations_input_string(bib)
-        p = Nokogiri::XML(bib) or return
-        (p.errors.empty? && p.root.at("./bibitem")) or return nil
-        p.root.xpath("./bibitem").each_with_object([]) do |b, m|
-          m << Relaton::Bib::Bibitem.from_xml(b.to_xml)
-        end
-      end
-
-      def citations1(bib)
-        bib.each_with_object([]).with_index do |(b, m), i|
-          data_liquid = @fieldsklass.new(renderer: self)
-            .compound_fields_format(@parse.extract(b))
-          m << { author: data_liquid[:authorcite], date: data_liquid[:date],
-                 ord: i, id: b.id, data: data_liquid, type: b.type }
-        end
-      end
-
-      # add to liquid data based on template
-      def enhance_data(_data, template)
-        template.is_a?(String) or return
-        # add_date_accessed(data, template)
-      end
-
-      # functionality removed: date needs to be given explicitly
-      def add_date_accessed(data, template)
-        (/\{\{\s*date_accessed\s*\}\}/.match?(template) &&
-          /\{\{\s*uri\s*\}\}/.match?(template) &&
-          data[:uri_raw] && !data[:date_accessed]) or return
-        if url_exist?(data[:uri_raw])
-          data[:date_accessed] = { on: ::Date.today.to_s }
-        else url_warn(data[:uri_raw])
-        end
-      end
-
-      def url_warn(uri)
-        @url_warned[uri] and return
-        warn "BIBLIOGRAPHY WARNING: cannot access #{uri}"
-        @url_warned[uri] = true
-      end
-
-      private
-
-      def template_hash_fill(templates)
-        BIBTYPE.each_with_object({}) do |type, m|
-          template = templates[type] || templates["misc"] || default_template
-          BIBTYPE.include?(template) and template = templates[template]
-          m[type] = template
-        end
-      end
-    end
-  end
-end

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