isodoc 2.10.0 → 3.0.0

data/lib/isodoc/presentation_function/docid.rb

@@ -0,0 +1,78 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def docid_prefixes(docxml)
+      docxml.xpath(ns("//references/bibitem/docidentifier")).each do |i|
+        i.children = docid_prefix(i["type"], to_xml(i.children))
+      end
+    end
+
+    def pref_ref_code(bib)
+      bib["suppress_identifier"] == "true" and return nil
+      ret = bib.xpath(ns("./docidentifier[@scope = 'biblio-tag']"))
+      ret.empty? or return ret.map { |x| to_xml(x.children) }
+      ret = pref_ref_code_parse(bib) or return nil
+      ins = bib.at(ns("./docidentifier[last()]"))
+      ret.reverse_each do |r|
+        ins.next = "<docidentifier scope='biblio-tag'>#{docid_l10n(r)}</docidentifier>"
+      end
+      ret
+    end
+
+    def pref_ref_code_parse(bib)
+      data, = @bibrender.parse(bib)
+      ret = data[:authoritative_identifier] or return nil
+      ret.empty? and return nil
+      ret
+    end
+
+    # returns [metanorma, non-metanorma, DOI/ISSN/ISBN] identifiers
+    def bibitem_ref_code(bib)
+      id, id1, id2, id3 = bibitem_ref_code_prep(bib)
+      id || id1 || id2 || id3 and return [id, id1, id2, id3]
+      bib["suppress_identifier"] == "true" and return [nil, nil, nil, nil]
+      [nil, no_identifier(bib), nil, nil]
+    end
+
+    def bibitem_ref_code_prep(bib)
+      id = bib.at(ns("./docidentifier[@type = 'metanorma']"))
+      id1 = pref_ref_code(bib)
+      id2 = bib.at(ns("./docidentifier[#{SKIP_DOCID}]"))
+      id3 = bib.at(ns("./docidentifier[@type = 'metanorma-ordinal']"))
+      [id, id1, id2, id3]
+    end
+
+    def no_identifier(bib)
+      @i18n.no_identifier or return nil
+      id = Nokogiri::XML::Node.new("docidentifier", bib.document)
+      id << @i18n.no_identifier
+      id
+    end
+
+    def bracket_if_num(num)
+      num.nil? and return nil
+      num = to_xml(num.children).sub(/^\[/, "").sub(/\]$/, "")
+      /^\d+$/.match?(num) and return "[#{num}]"
+      num
+    end
+
+    def unbracket1(ident)
+      ident.nil? and return nil
+      ident.is_a?(String) or ident = to_xml(ident.children)
+      ident.sub(/^\[/, "").sub(/\]$/, "")
+    end
+
+    def unbracket(ident)
+      if ident.respond_to?(:size)
+        ident.map { |x| unbracket1(x) }.join("&#xA0;/ ")
+      else unbracket1(ident)
+      end
+    end
+
+    def render_identifier(ident)
+      { metanorma: bracket_if_num(ident[0]),
+        sdo: unbracket(ident[1]),
+        doi: unbracket(ident[2]),
+        ordinal: bracket_if_num(ident[3]) }
+    end
+  end
+end

data/lib/isodoc/presentation_function/erefs.rb

@@ -3,10 +3,24 @@ require "metanorma-utils"
 module IsoDoc
   class PresentationXMLConvert < ::IsoDoc::Convert
     def citeas(xmldoc)
-      xmldoc.xpath(ns("//eref | //origin | //quote/source")).each do |e|
+      xmldoc.xpath(ns("//fmt-eref | //fmt-origin | //fmt-link"))
+        .each do |e|
+          sem_xml_descendant?(e) and next
         e["bibitemid"] && e["citeas"] or next
-        a = @xrefs.anchor(e["bibitemid"], :xref, false) and e["citeas"] = a
+        a = @xrefs.anchor(e["bibitemid"], :xref, false) or next
+        e["citeas"] = citeas_cleanup(a)
+        # link generated in collection postprocessing from eref
+        e.name == "fmt-link" && e.text.empty? and e.children = e["citeas"]
+      end
+    end
+
+    def citeas_cleanup(ref)
+      if /</.match?(ref)
+        xml = Nokogiri::XML("<root>#{ref}</root>")
+        xml.xpath("//semx").each { |x| x.replace(x.children) }
+        ref = to_xml(xml.at("//root").children)
       end
+      ref
     end
 
     def expand_citeas(text)
@@ -15,11 +29,13 @@ module IsoDoc
     end
 
     def erefstack1(elem)
-      locs = elem.xpath(ns("./eref")).map do |e|
-        [e["connective"], to_xml(e)]
+      locs = elem.xpath(ns("./semx/fmt-eref")).map do |e|
+        [e["connective"], to_xml(e.parent.remove)]
       end.flatten
       ret = resolve_eref_connectives(locs)
-      elem.replace(ret[1])
+      elem["id"] ||= "_#{UUIDTools::UUID.random_create}"
+      elem.next = "<semx element='erefstack' source='#{elem['id']}'>#{ret[1]}</semx>"
+      #elem.replace(ret[1])
     end
 
     def eref_localities(refs, target, node)
@@ -38,9 +54,9 @@ module IsoDoc
       ret = resolve_eref_connectives(eref_locality_stacks(refs, target,
                                                           node))
       node.delete("droploc") unless droploc
-      eref_localities1({ target: target, number: "pl",
+      eref_localities1({ target:, number: "pl",
                          type: refs.first.at(ns("./locality/@type")).text,
-                         from: l10n(ret[1..-1].join), node: node, lang: @lang })
+                         from: l10n(ret[1..].join), node:, lang: @lang })
     end
 
     def can_conflate_eref_rendering?(refs)
@@ -48,16 +64,13 @@ module IsoDoc
         refs.all? { |r| r.name == "localityStack" } &&
         refs.all? { |r| r.xpath(ns("./locality")).size == 1 }) or return false
       first = refs.first.at(ns("./locality/@type")).text
-      refs.all? do |r|
-        r.at(ns("./locality/@type")).text == first
-      end
+      refs.all? { |r| r.at(ns("./locality/@type")).text == first }
     end
 
     def resolve_eref_connectives(locs)
       locs = resolve_comma_connectives(locs)
       locs = resolve_to_connectives(locs)
-      return locs if locs.size < 3
-
+      locs.size < 3 and return locs
       locs = locs.each_slice(2).with_object([]) do |a, m|
         m << { conn: a[0], label: a[1] }
       end
@@ -90,7 +103,8 @@ module IsoDoc
       locs1 = []
       until locs.empty?
         if locs[1] == "to"
-          locs1 << @i18n.chain_to.sub("%1", locs[0]).sub("%2", locs[2])
+          locs1 << connectives_spans(@i18n.chain_to.sub("%1", locs[0])
+            .sub("%2", locs[2]))
           locs.shift(3)
         else locs1 << locs.shift
         end
@@ -143,14 +157,13 @@ module IsoDoc
     def eref_localities0(ref, _idx, target, node)
       if ref["type"] == "whole" then @i18n.wholeoftext
       else
-        eref_localities1({ target: target, type: ref["type"], number: "sg",
+        eref_localities1({ target:, type: ref["type"], number: "sg",
                            from: ref.at(ns("./referenceFrom"))&.text,
-                           upto: ref.at(ns("./referenceTo"))&.text, node: node,
+                           upto: ref.at(ns("./referenceTo"))&.text, node:,
                            lang: @lang })
       end
     end
 
-    # def eref_localities1_zh(_target, type, from, upto, node)
     def eref_localities1_zh(opt)
       ret = "第#{opt[:from]}" if opt[:from]
       ret += "&#x2013;#{opt[:upto]}" if opt[:upto]
@@ -159,11 +172,9 @@ module IsoDoc
       ret
     end
 
-    # def eref_localities1(target, type, from, upto, node, lang = "en")
     def eref_localities1(opt)
       opt[:type] == "anchor" and return nil
       opt[:lang] == "zh" and
-        # return l10n(eref_localities1_zh(target, type, from, upto, node))
         return l10n(eref_localities1_zh(opt))
       ret = eref_locality_populate(opt[:type], opt[:node], opt[:number])
       ret += " #{opt[:from]}" if opt[:from]
@@ -184,18 +195,20 @@ module IsoDoc
     end
 
     def eref2link(docxml)
-      docxml.xpath(ns("//eref | //origin[not(termref)] | //quote/source"))
+      docxml.xpath(ns("//display-text")).each { |f| f.replace(f.children) }
+      docxml.xpath(ns("//fmt-eref | //fmt-origin[not(.//termref)]"))
         .each do |e|
+          sem_xml_descendant?(e) and next
         href = eref_target(e) or next
         e.xpath(ns("./locality | ./localityStack")).each(&:remove)
-        if /^#/.match?(href) then eref2xref(e)
+        if href[:type] == :anchor then eref2xref(e)
         else eref2link1(e, href)
         end
       end
     end
 
     def eref2xref(node)
-      node.name = "xref"
+      node.name = "fmt-xref"
       node["target"] = node["bibitemid"]
       node.delete("bibitemid")
       node.delete("citeas")
@@ -203,7 +216,9 @@ module IsoDoc
     end
 
     def eref2link1(node, href)
-      repl = "<link target='#{href}'>#{node.children}</link>"
+      url = href[:link]
+      att = href[:type] == :attachment ? "attachment='true'" : ""
+      repl = "<fmt-link #{att} target='#{url}'>#{node.children}</link>"
       node["type"] == "footnote" and repl = "<sup>#{repl}</sup>"
       node.replace(repl)
     end
@@ -215,20 +230,29 @@ module IsoDoc
     end
 
     def eref_target(node)
-      url = suffix_url(eref_url(node["bibitemid"]))
+      u = eref_url(node["bibitemid"]) or return nil
+      url = suffix_url(u[:link])
       anchor = node.at(ns(".//locality[@type = 'anchor']"))
-      return url if url.nil? || /^#/.match?(url) || !anchor
+      /^#/.match?(url) || !anchor and return { link: url, type: u[:type] }
+      { link: "#{url}##{anchor.text.strip}", type: u[:type] }
+    end
 
-      "#{url}##{anchor.text.strip}"
+    def eref_url_prep(id)
+      @bibitem_lookup.nil? and return nil
+      @bibitem_lookup[id]
     end
 
     def eref_url(id)
-      @bibitem_lookup.nil? and return nil
-      b = @bibitem_lookup[id] or return nil
-      url = b.at(ns("./uri[@type = 'citation'][@language = '#{@lang}']")) ||
-        b.at(ns("./uri[@type = 'citation']")) and return url.text
-      b["hidden"] == "true" and return b.at(ns("./uri"))&.text
-      "##{id}"
+      b = eref_url_prep(id) or return nil
+      %i(attachment citation).each do |x|
+        u = b.at(ns("./uri[@type = '#{x}'][@language = '#{@lang}']")) ||
+          b.at(ns("./uri[@type = '#{x}']")) and return { link: u.text, type: x }
+      end
+      if b["hidden"] == "true"
+        u = b.at(ns("./uri")) or return nil
+        { link: u.text, type: :citation }
+      else { link: "##{id}", type: :anchor }
+      end
     end
   end
 end

data/lib/isodoc/presentation_function/image.rb

@@ -20,8 +20,11 @@ module IsoDoc
     end
 
     def svgmap_extract(elem)
-      if f = elem.at(ns("./figure")) then elem.replace(f)
-      else elem.remove
+      if elem.at(ns("./figure"))# then elem.replace(f)
+        n = semx_fmt_dup(elem)
+        n.xpath(ns("./target")).each(&:remove)
+        elem.next = n
+      #else elem.remove
       end
     end
 
@@ -38,21 +41,59 @@ module IsoDoc
 
       svg = Base64.strict_decode64(elem["src"]
         .sub(%r{^data:image/svg\+xml;(charset=[^;]+;)?base64,}, ""))
-      x = Nokogiri::XML.fragment(svg.sub(/<\?xml[^>]*>/, "")) do |config|
-        config.huge
-      end
+      x = Nokogiri::XML.fragment(svg.sub(/<\?xml[^<>]*>/, ""), &:huge)
       elem["src"] = ""
       elem.children = x
     end
 
+    def subfigure_delim
+      ""
+      # "<span class='fmt-label-delim'>)</span>"
+    end
+
+    def figure_delim(_elem)
+      block_delim
+    end
+
+    def figure_name(elem)
+      "<span class='fmt-element-name'>#{figure_label(elem)}</span> "
+    end
+
     def figure1(elem)
-      return sourcecode1(elem) if elem["class"] == "pseudocode" ||
-        elem["type"] == "pseudocode"
-      return if elem.at(ns("./figure")) && !elem.at(ns("./name"))
+      elem["class"] == "pseudocode" || elem["type"] == "pseudocode" and
+        return sourcecode1(elem)
+      figure_fn(elem)
+      figure_key(elem.at(ns("./dl")))
+      lbl = @xrefs.anchor(elem["id"], :label, false)
+      lbl and a = autonum(elem["id"], lbl)
+      figname = figure_name(elem)
+      (elem.parent.name == "figure") && a and
+        a += subfigure_delim
+      lbl && figure_label?(elem) and s = "#{figname}#{a}"
+      prefix_name(elem, { caption: figure_delim(elem) }, l10n(s&.strip), "name")
+    end
+
+    # move footnotes into key, and get rid of footnote reference
+    # since it is in diagram
+    def figure_fn(elem)
+      fn = elem.xpath(ns(".//fn")) - elem.xpath(ns("./name//fn"))
+      fn.empty? and return
+      dl = figure_key_insert_pt(elem)
+      fn.each do |f|
+        dl.previous = "<dt><p><sup>#{f['reference']}</sup></p></dt>" \
+          "<dd>#{f.remove.children.to_xml}</dd>"
+      end
+    end
 
-      lbl = @xrefs.anchor(elem["id"], :label, false) or return
-      prefix_name(elem, block_delim,
-                  l10n("#{figure_label(elem)} #{lbl}"), "name")
+    def figure_key_insert_pt(elem)
+      elem.at(ns("//dl/name"))&.next ||
+        elem.at(ns("//dl"))&.children&.first ||
+        elem.add_child("<dl> </dl>").first.children.first
+    end
+
+    def figure_label?(elem)
+      elem.at(ns("./figure")) && !elem.at(ns("./name")) and return false
+      true
     end
 
     def figure_label(elem)
@@ -61,6 +102,14 @@ module IsoDoc
       lower2cap klasslbl
     end
 
+    def figure_key(dlist)
+      dlist or return
+      dlist["class"] = "formula_dl"
+      dlist.at(ns("./name")) and return
+      dlist.previous =
+        "<p keep-with-next='true'><strong>#{@i18n.key}</strong></p>"
+    end
+
     def eps2svg(img)
       return unless eps?(img["mimetype"])
 
@@ -74,7 +123,8 @@ module IsoDoc
     def svg_emf_double(img)
       if emf?(img["mimetype"])
         img = emf_encode(img)
-        img.children.first.previous = emf_to_svg(img)
+        # img.children.first.previous = emf_to_svg(img)
+        img.add_first_child emf_to_svg(img)
       elsif img["mimetype"] == "image/svg+xml"
         src = svg_to_emf(img) or return
         img.add_child("<emf/>")
@@ -123,16 +173,11 @@ module IsoDoc
 
     def svg_to_emf(node)
       @output_formats[:doc] or return
-
       svg_impose_height_attr(node)
-
-      if node.elements&.first&.name == "svg" || %r{^data:}.match?(node["src"])
+      node.elements&.first&.name == "svg" || %r{^data:}.match?(node["src"]) and
         return svg_to_emf_from_node(node)
-      end
-
       target_path = imgfile_suffix(node["src"], "emf")
-      return target_path if File.exist?(target_path)
-
+      File.exist?(target_path) and return target_path
       svg_to_emf_from_node(node, target_path)
     end
 

data/lib/isodoc/presentation_function/index.rb

@@ -0,0 +1,180 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def enable_indexsect
+      false
+    end
+
+    def add_id
+      %(id="_#{UUIDTools::UUID.random_create}")
+    end
+
+    def strip_index(docxml)
+      docxml.xpath(ns("//index | //index-xref | //indexsect")).each(&:remove)
+    end
+
+    def index(xml)
+      if enable_indexsect && xml.at(ns("//index"))
+        i = xml.at(ns("//indexsect")) ||
+          xml.root.add_child("<indexsect #{add_id}><title>#{@i18n.index}" \
+                             "</title></indexsect>").first
+        index = sort_indexterms(xml.xpath(ns("//index")),
+                                xml.xpath(ns("//index-xref[@also = 'false']")),
+                                xml.xpath(ns("//index-xref[@also = 'true']")))
+        index1(xml, i, index)
+      else strip_index(xml)
+      end
+    end
+
+    def index1(docxml, indexsect, index)
+      c = indexsect.add_child("<ul></ul>").first
+      index.keys.sort.each do |k|
+        words = index[k].keys.each_with_object({}) do |w, v|
+          v[sortable(w).downcase] = w
+        end
+        words.keys.localize(@lang.to_sym).sort.to_a.each do |w|
+          c.add_child index_entries(words, index[k], w)
+        end
+      end
+      index1_cleanup(docxml)
+    end
+
+    def index1_cleanup(docxml)
+      docxml.xpath(ns("//indexsect//xref")).each do |x|
+        x.children.remove
+      end
+      @xrefs.bookmark_anchor_names(docxml)
+    end
+
+    def sortable(str)
+      str or return " "
+      HTMLEntities.new.decode(Nokogiri::XML.fragment(str).text)
+    end
+
+    def index_entries_opt
+      { xref_lbl: ", ", see_lbl: ", #{see_lbl}", also_lbl: ", #{also_lbl}" }
+    end
+
+    def index_entries(words, index, primary)
+      ret = index_entries_head(words[primary],
+                               index.dig(words[primary], nil, nil),
+                               index_entries_opt)
+      words2 = index[words[primary]]&.keys&.compact
+        &.each_with_object({}) { |w, v| v[w.downcase] = w }
+      unless words2.empty?
+        ret += "<ul>"
+        words2.keys.localize(@lang.to_sym).sort.to_a.each do |w|
+          ret += index_entries2(words2, index[words[primary]], w)
+        end
+        ret += "</ul>"
+      end
+      "#{ret}</li>"
+    end
+
+    def index_entries2(words, index, secondary)
+      ret = index_entries_head(words[secondary],
+                               index.dig(words[secondary], nil),
+                               index_entries_opt)
+      words3 = index[words[secondary]]&.keys&.compact
+        &.each_with_object({}) { |w, v| v[w.downcase] = w }
+      unless words3.empty?
+        ret += "<ul>"
+        words3.keys.localize(@lang.to_sym).sort.to_a.each do |w|
+          ret += (index_entries_head(words3[w],
+                                     index[words[secondary]][words3[w]],
+                                     index_entries_opt) + "</li>")
+        end
+        ret += "</ul>"
+      end
+      "#{ret}</li>"
+    end
+
+    def index_entries_head(head, entries, opt)
+      ret = "<li>#{head}"
+      xref = entries&.dig(:xref)&.join(", ")
+      see = index_entries_see(entries, :see)
+      also = index_entries_see(entries, :also)
+      ret += "#{opt[:xref_lbl]} #{xref}" if xref
+      ret += "#{opt[:see_lbl]} #{see}" if see
+      ret += "#{opt[:also_lbl]} #{also}" if also
+      ret
+    end
+
+    def index_entries_see(entries, label)
+      see_sort = entries&.dig(label) or return nil
+      x = see_sort.each_with_object({}) do |w, v|
+        v[sortable(w).downcase] = w
+      end
+      x.keys.localize(@lang.to_sym).sort.to_a.map do |k|
+        # see_sort[k]
+        x[k]
+      end.join(", ")
+    end
+
+    def see_lbl
+      @lang == "en" ? @i18n.see : "<em>#{@i18n.see}</em>"
+    end
+
+    def also_lbl
+      @lang == "en" ? @i18n.see_also : "<em>#{@i18n.see_also}</em>"
+    end
+
+    def sort_indexterms(terms, see, also)
+      index = extract_indexterms(terms)
+      index = extract_indexsee(index, see, :see)
+      index = extract_indexsee(index, also, :also)
+      index.keys.sort.each_with_object({}) do |k, v|
+        v[sortable(k)[0].upcase.transliterate] ||= {}
+        v[sortable(k)[0].upcase.transliterate][k] = index[k]
+      end
+    end
+
+    def extract_indexsee(val, terms, label)
+      terms.each_with_object(val) do |t, v|
+        term, term2, term3 = extract_indexterms_init(t)
+        term_hash_init(v, term, term2, term3, label)
+        v[term][term2][term3][label] << to_xml(t.at(ns("./target"))&.children)
+        t.remove
+      end
+    end
+
+    def xml_encode_attr(str)
+      HTMLEntities.new.encode(str, :basic, :hexadecimal)
+        .gsub(/&#x([^;]+);/) do |_x|
+        "&#x#{$1.upcase};"
+      end
+    end
+
+    # attributes are decoded into UTF-8,
+    # elements in extract_indexsee are still in entities
+    def extract_indexterms(terms)
+      terms.each_with_object({}) do |t, v|
+        term, term2, term3 = extract_indexterms_init(t)
+        to = t["to"] ? "to='#{t['to']}' " : ""
+        index2bookmark(t)
+        term_hash_init(v, term, term2, term3, :xref)
+        v[term][term2][term3][:xref] << "<xref target='#{t['id']}' " \
+                                        "#{to}pagenumber='true'/>"
+      end
+    end
+
+    def extract_indexterms_init(term)
+      %w(primary secondary tertiary).each_with_object([]) do |x, m|
+        m << to_xml(term.at(ns("./#{x}"))&.children)
+      end
+    end
+
+    def term_hash_init(hash, term, term2, term3, label)
+      hash[term] ||= {}
+      hash[term][term2] ||= {}
+      hash[term][term2][term3] ||= {}
+      hash[term][term2][term3][label] ||= []
+    end
+
+    def index2bookmark(node)
+      node.name = "bookmark"
+      node.children.each(&:remove)
+      node["id"] = "_#{UUIDTools::UUID.random_create}"
+      node.delete("to")
+    end
+  end
+end