relaton-render 1.4.0.pre.alpha.4 → 3.0.0.pre.alpha.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 50d68785ac0e26c28b114b0080e9d2057f701801d641baf0fa955819edaaa7f3
-  data.tar.gz: 2c150fa61c2c5a073c372ab8492f897a25294f02f104cc5a442b17cd8efe4104
+  metadata.gz: 9f7785209c01d3c056fa9d516f1cafe5ba50325f28ac5514cc823fba010eb385
+  data.tar.gz: 76b64df9733dd15acb659ca35ca7cdafdd1aaac8246c2881ab544e9949f77221
 SHA512:
-  metadata.gz: 2206dd123a1cab3a5ae0602e4de1cc71b71aaaac67f1a68474db7c367b10a29a52d08dc477770770295b48d89cfbae263bd314818d9cf5bcb1f722576a479f7c
-  data.tar.gz: 7270b105580e34e9637172aa3953d50b6bf9bdb51a9d9d9dfe55f6438bb9d026cf2d891b2c6f3b74add5b9bca73b4c8916fd6d33369e972b9ae87207398d33b1
+  metadata.gz: b2fa95a3486e245bfcafca4ce8b0b14295a5a7eb2220ce6720b958a8e7b73c3ec585f3761e2f749309938f64b102561562b81e999a24f8d45153abf4faedf95e
+  data.tar.gz: 1152dfa988e10a2b1f1772c7e2c82a707d01ffa52c61f4b97ed69e128eb2de700a93dd12e16e5351e124c4e717ed2976bafc148cdd245e243c6a7c962da1b57d

data/lib/relaton/render/fields/date.rb

@@ -0,0 +1,48 @@
+module Relaton
+  module Render
+    class Date
+      def initialize(date, options)
+        @date = date
+        @r = options[:renderer]
+        @type = options[:type]
+        @bibitem = options[:bibitem]
+      end
+
+      def render
+        return @date if @date.nil? || /^\d+$/.match?(@date)
+
+        render1(granularity)
+      end
+
+      # @r.date is using document language setting, not citation-specific
+      def render1(format)
+        datef = dateparse(format, @r.lang.to_sym)
+        case @r.date[format]
+        when "to_full_s", "to_long_s", "to_medium_s", "to_short_s"
+          datef.send @r.date[format]
+        else
+          datef.to_additional_s(@r.date[format])
+        end
+      end
+
+      def granularity
+        case @date
+        when /^\d+-\d+$/ then "month_year"
+        when /^\d+-\d+-\d+$/ then "day_month_year"
+        else "date_time"
+        end
+      end
+
+      def dateparse(format, lang)
+        case format
+        when "date_time"
+          DateTime.parse(@date).localize(lang, timezone: "Zulu")
+        when "day_month_year"
+          DateTime.parse(@date).localize(lang, timezone: "Zulu").to_date
+        when "month_year"
+          DateTime.parse("#{@date}-01").localize(lang, timezone: "Zulu").to_date
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/fields/fields.rb

@@ -0,0 +1,266 @@
+require_relative "date"
+
+module Relaton
+  module Render
+    class Fields
+      def initialize(options)
+        @r = options[:renderer]
+      end
+
+      # the @i18n.select choices here need to rely on
+      # fields already present, they can't rely on fields they are yet to build
+      def compound_fields_format(hash)
+        name_fields_format(hash)
+        role_fields_format(hash)
+        date_fields_format(hash)
+        edition_fields_format(hash)
+        place_fields_format(hash)
+        series_fields_format(hash)
+        misc_fields_format(hash)
+      end
+
+      def comma(hash)
+        "#{@r.i18n.select(hash).get.dig('punct', 'comma') || ','} "
+      end
+
+      def place_fields_format(hash)
+        hash[:place_raw]&.map! do |p|
+          # TODO use enum-comma?
+          if p.is_a?(Array)
+            p.join(comma(hash))
+          else p
+          end
+        end
+        hash[:place] =
+          nameformat(hash[:place_raw].map { |x| { nonpersonal: x } }, hash)
+      end
+
+      def name_fields_format(hash)
+        [%i(creatornames creators), %i(host_creatornames host_creators),
+         %i(publisher publisher_raw), %i(distributor distributor_raw),
+         %i(authorizer authorizer_raw)]
+          .each do |k|
+          hash[k[0]] = nameformat(hash[k[1]], hash)
+        end
+        hash[:publisher_abbrev] = hash[:publisher_abbrev_raw]&.join(comma(hash))
+        hash[:authorcite] = authorciteformat(hash[:creators], hash)
+      end
+
+      def role_fields_format(hash)
+        hash[:role] = role_inflect(hash[:creators], hash[:role_raw], hash)
+        hash[:host_role] =
+          role_inflect(hash[:host_creators], hash[:host_role_raw], hash)
+      end
+
+      def edition_fields_format(hash)
+        hash[:edition] =
+          editionformat(hash[:edition_raw], hash[:edition_num], hash)
+        hash[:draft] = draftformat(hash[:draft_raw], hash)
+      end
+
+      def misc_fields_format(hash)
+        hash[:medium] = mediumformat(hash[:medium_raw], hash)
+        hash[:extent] = extentformat(hash[:extent_raw], hash)
+        hash[:size] = sizeformat(hash[:size_raw], hash)
+        hash[:uri] = uriformat(hash[:uri_raw])
+        hash[:status] = statusformat(hash[:status_raw], hash)
+        hash[:other_identifier] =
+          otheridentifierformat(hash[:other_identifier_raw], hash)
+        hash
+      end
+
+      def otheridentifierformat(otherids, _hash)
+        otherids&.map do |i|
+          # ret = "#{i[0]}: <esc>#{i[1]}</esc>"
+          # @r.i18n.select(hash).l10n(ret) # no i18n!
+          "#{i[0]}: #{i[1]}"
+        end
+      end
+
+      def statusformat(status, hash)
+        status.nil? and return
+        @r.i18n.select(hash).get.dig("stage", status) || status
+      end
+
+      # date => disambiguated_date, the disambiguation happens in citations/
+      def date_fields_format(hash)
+        [%i(date date), %i(disambiguated_date date),
+         %i(date_updated date_updated),
+         %i(date_accessed date_accessed)].each do |k|
+          hash[k[0]] = dateformat(hash[k[1]], hash, k)
+          k[1] == :date &&
+            !%w(standard webresource website).include?(hash[:type]) and
+            hash[k[0]] ||= @r.i18n.select(nil).get["no_date"]
+        end
+      end
+
+      def mediumformat(medium, hash)
+        medium.nil? and return nil
+        ret = %w(content genre form carrier size
+                 scale).each_with_object([]) do |i, m|
+          m << "<esc>#{medium[i]}</esc>" if medium[i]
+          m
+        end.compact
+        i = @r.i18n.select(hash)
+        i.l10n(ret.join(comma(hash)))
+      end
+
+      def series_fields_format(hash)
+        parts =
+          %i(series_title series_abbr series_num series_partnumber
+             series_run series_formatted series_dates series_place series_org)
+        series_out = parts.each_with_object({}) do |i, m|
+          m[i] = hash[i]
+        end
+        t = hash[:type] == "article" ? @r.journaltemplate : @r.seriestemplate
+        hash[:series] = t.render(series_out, hash)
+      end
+
+      def nameformat(names, hash)
+        names.nil? and return names
+        parts = %i(surname initials given middle nonpersonal)
+        names_out = names.each_with_object({}) do |n, m|
+          parts.each do |i|
+            m[i] ||= []
+            m[i] << n[i]
+          end
+        end
+        @r.nametemplate.render(names_out, hash)
+      end
+
+      def authorciteformat(names, hash)
+        names.nil? || @r.authorcitetemplate.nil? and return names
+        parts = %i(surname initials given middle nonpersonal)
+        names_out = names.each_with_object({}) do |n, m|
+          parts.each do |i|
+            m[i] ||= []
+            m[i] << n[i]
+          end
+        end
+        @r.authorcitetemplate.render(names_out, hash)
+      end
+
+      def role_inflect(contribs, role, hash)
+        role.nil? || contribs.empty? ||
+          %w(author publisher distributor
+             authorizer).include?(role) and return nil
+        number = contribs.size > 1 ? "pl" : "sg"
+        x = @r.i18n.select(hash).get[role]
+        x.is_a?(Hash) or return role
+        x[number] || role
+      end
+
+      def editionformat(edn, num, hash)
+        num || edn && !edn.empty? or return
+        edn_num = edn&.gsub(/<\/?esc>/, "")
+        num || /^\d+$/.match?(edn_num) and
+          return @r.i18n.select(hash)
+              .populate("edition_ordinal", { "var1" => num || edn_num.to_i })
+        @r.i18n.select(hash).populate("edition_cardinal", { "var1" => edn })
+      end
+
+      def draftformat(num, hash)
+        num.nil? ||
+          (num.is_a?(Hash) && num[:status].nil? &&
+            num[:iteration].nil?) and return nil
+        @r.i18n.select(hash).draft.sub("%", num)
+      end
+
+      def extentformat(extent, hash)
+        extent.map do |stack|
+          stack.map do |e|
+            e1 = e.transform_values { |v| v.is_a?(Hash) ? range(v) : v }
+            ret = e.each_with_object({}) do |(k, v), m|
+              extentformat1(k, v, m, e1, hash)
+              m
+            end
+            @r.extenttemplate.render(hash.merge(ret), hash)
+          end.join(" ")
+        end.join("; ")
+      end
+
+      def extentformat1(key, val, hash, norm_hash, context)
+        if %i(volume issue page).include?(key)
+          hash["#{key}_raw".to_sym] = norm_hash[key]
+          hash[key] =
+            pagevolformat(norm_hash[key], val, key.to_s, false, context)
+        end
+      end
+
+      def range(hash)
+        hash[:on] and return hash[:on]
+        hash.has_key?(:from) && hash[:from].nil? and return nil
+        !hash[:from] and return hash
+        hash[:to] && hash[:to] != hash[:from] and
+          return "#{hash[:from]}&#x2013;#{hash[:to]}"
+        hash[:from]
+      end
+
+      def sizeformat(size, hash)
+        return nil unless size
+
+        ret = size.transform_values do |v|
+          @r.i18n.select(hash).l10n(v.join(" + "))
+        end
+          .each_with_object({}) do |(k, v), m|
+            sizeformat1(k, v, m, hash)
+            m
+          end
+        @r.sizetemplate.render(ret.merge(type: hash[:type]), hash)
+      end
+
+      def sizeformat1(key, val, hash, context)
+        case key
+        when "volume", "issue", "page"
+          hash["#{key}_raw".to_sym] = val
+          hash[key.to_sym] = pagevolformat(val, nil, key, true, context)
+        when "data" then hash[:data] = val
+        when "duration" then hash[:duration] = val
+        end
+      end
+
+      def pagevolformat(value, value_raw, type, is_size, hash)
+        value.nil? and return nil
+        num = "pl"
+        if is_size
+          value == "1" and num = "sg"
+        else
+          value_raw[:to] or num = "sg"
+        end
+        i = @r.i18n.select(hash)
+        i.l10n(i.get[is_size ? "size" : "extent"][type][num]
+        .sub("%", value))
+      end
+
+      def date_range(hash)
+        hash[:from] && !hash[:to] and return "#{hash[:from]}&#x2013;"
+        range(hash)
+      end
+
+      def dateformat(date, hash, type)
+        date.nil? and return nil
+        date.is_a?(String) and return date
+        %i(from to on).each do |k|
+          date[k] = @r.dateklass
+            .new(date[k], renderer: @r, bibitem: hash, type: type).render
+        end
+        date_range(date)
+      end
+
+      def uriformat(uri)
+        uri.nil? || uri.empty? and return nil
+        # do not process uri contents in l10n
+        "<fmt-link target='#{uri}'><esc>#{uri}</esc></fmt-link>"
+      end
+
+      private
+
+      def tw_cldr_lang
+        if @r.lang != "zh" then @r.lang.to_sym
+        elsif @r.script == "Hant" then :"zh-tw"
+        else :"zh-cn"
+        end
+      end
+    end
+  end
+end

data/lib/relaton/render/general.rb

@@ -25,6 +25,7 @@ module Relaton
       CiteTemplate = Struct.new(:template_raw)
 
       def initialize(options = {})
+        options = deep_symbolize(options)
         @lang = options[:language] || options[:lang] || "en"
         @renderer = Iso690::Renderer.new(
           lang: @lang,
@@ -145,6 +146,17 @@ module Relaton
         end
       end
 
+      # 1.x accepted string- and symbol-keyed options alike (the old
+      # engine deep-symbolized via metanorma-utils); isodoc's bibrenderer
+      # and every flavor still pass string keys.
+      def deep_symbolize(value)
+        case value
+        when Hash then value.to_h { |k, v| [k.to_sym, deep_symbolize(v)] }
+        when Array then value.map { |v| deep_symbolize(v) }
+        else value
+        end
+      end
+
       def warn_general_config
         return if General.config_warned
 

data/lib/relaton/render/legacy/citations.rb

@@ -0,0 +1,178 @@
+module Relaton
+  module Render
+    class Citations
+      def initialize(opt = {})
+        # invoking i18n hash, but we preference the specific renderer's i18n
+        @i18n = opt[:i18n]
+        @lang = opt[:lang] # document lang and script
+        @script = opt[:script]
+        # hash of renderers, to be applied to specific citation by selector
+        @renderer = opt[:renderer]
+      end
+
+      def renderer(_cite)
+        @renderer[:default]
+      end
+
+      # takes array of { id, type, author, date, ord, data }
+      def render(ret)
+        cites = citations(ret)
+        enhance_data(cites)
+        cites.each_key do |k|
+          cites[k] = render1(cites[k])
+        end
+        cites
+      end
+
+      def enhance_data(cites)
+        ret = extract_uris_for_lookup(cites)
+        ret.empty? and return
+        # functionality removed: date needs to be given explicitly
+        # @renderer.urls_exist_concurrent(ret.keys).each do |k, v|
+        # ret[k].each { |u| add_date_accessed(cites[u], k, v) }
+        # end
+      end
+
+      def extract_uris_for_lookup(cites)
+        cites.each_with_object({}) do |(k, v), m|
+          u = extract_uri_for_lookup(v) or next
+          m[u] ||= []
+          m[u] << k
+        end
+      end
+
+      def extract_uri_for_lookup(cite)
+        t = renderer(cite).renderer(cite[:type] || "misc").template_raw
+        c = cite[:data]
+        t.is_a?(String) or return
+        (/\{\{\s*date_accessed\s*\}\}/.match?(t) &&
+        /\{\{\s*uri\s*\}\}/.match?(t) &&
+        c[:uri_raw] && !c[:date_accessed]) or return
+        c[:uri_raw]
+      end
+
+      def add_date_accessed(cite, uri, status)
+        r = renderer(cite)
+        if status
+          cite[:data][:date_accessed] = { on: ::Date.today.to_s }
+          cite[:data] = r.fieldsklass.new(renderer: r)
+            .compound_fields_format(cite[:data])
+        else
+          r.url_warn(uri)
+        end
+      end
+
+      def render1(cit)
+        ref, ref1, r = render1_prep(cit)
+        i = @i18n.select(cit[:data])
+        cit[:formattedref] =
+          r.valid_parse(i.l10n(ref1))
+        cit[:citation][:full] = r.valid_parse(i.l10n(ref))
+        %i(type data renderer).each { |x| cit.delete(x) }
+        cit
+      end
+
+      def use_terminator?(ref, final, _cit)
+        !ref || ref.empty? and return false
+        !ref.end_with?(final)
+      end
+
+      def render1_prep(cit)
+        r = renderer(cit)
+        ref = r.renderer(cit[:type] || "misc").render(cit[:data], cit[:data])
+        final = @i18n.select(cit[:data]).get
+          .dig("punct", "biblio-terminator") || "."
+        ref1 = ref
+        use_terminator?(ref, final, cit) and ref1 += final
+        [ref, ref1, r]
+      end
+
+      # TODO: configure how multiple ids are joined, from template?
+      def citations(ret)
+        ret = disambig_author_date_citations(ret)
+        ret.each_value do |b|
+          i = @i18n.select(b[:data])
+          b[:citation][:default] =
+            i.l10n(b[:data][:authoritative_identifier]&.first || "")
+          d = b[:data].merge(citestyle: "short")
+          b[:citation][:short] = i.l10n(renderer(b).citeshorttemplate.render(d, d))
+          citations_iterate_cite_styles(b, i)
+        end
+        ret
+      end
+
+      def citations_iterate_cite_styles(bib, i18n)
+        r = renderer(bib)
+        r.citetemplate.citation_styles.each do |style|
+          bib[:citation][style] =
+            i18n.l10n(r.citetemplate
+            .render(bib.merge(citestyle: style)
+            .merge(bib[:data]), bib[:data]))
+        end
+      end
+
+      # takes array of { id, type, author, date, ord, data }
+      def disambig_author_date_citations(ret)
+        author_date_to_hash(suffix_date(sort_ord(author_date_breakdown(ret))))
+      end
+
+      def author_date_breakdown(ret)
+        ret.each_with_object({}) do |b, m|
+          m[b[:author]] ||= {}
+          m[b[:author]][b[:date]] ||= []
+          m[b[:author]][b[:date]] << b
+        end
+      end
+
+      def sort_ord(ret)
+        ret.each do |author, v|
+          v.each_key do |date|
+            ret[author][date].sort_by! { |a| a[:ord] }
+          end
+        end
+      end
+
+      def suffix_date(ret)
+        ret.each do |k, v|
+          v.each do |k1, v1|
+            s =  v1.reject { |b| b[:date].nil? }.size
+            s.zero? || k.nil? and next
+            suffix_date1(ret, k, k1, s)
+            copy_date_fields(ret, k, k1)
+          end
+        end
+        ret
+      end
+
+      def suffix_date1(ret, key1, key2, size)
+        size > 1 or return
+        ret[key1][key2].each_with_index do |b, i|
+          b[:date].nil? and next
+          b[:disambiguated_date] = b[:date] + ("a".ord + i).chr.to_s
+        end
+      end
+
+      def copy_date_fields(ret, key1, key2)
+        ret[key1][key2].each do |b|
+          b[:date].nil? and next
+          b[:data][:date] = b[:date]
+          b[:disambiguated_date] ||= b[:date]
+          b[:data][:disambiguated_date] = b[:disambiguated_date]
+        end
+      end
+
+      def author_date_to_hash(ret)
+        ret.each_with_object({}) do |(_k, v), m|
+          v.each_value do |v1|
+            v1.each do |b|
+              m[b[:id]] = { author: @i18n.select(b[:data]).l10n(b[:author]),
+                            date: b[:disambiguated_date] || b[:date],
+                            citation: {},
+                            data: b[:data], type: b[:type] }
+            end
+          end
+        end
+      end
+    end
+  end
+end

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