metanorma-standoc 1.10.6 → 1.11.0.1

data/lib/asciidoctor/standoc/cleanup_inline.rb

@@ -1,4 +1,5 @@
 require "metanorma-utils"
+require "digest"
 
 module Asciidoctor
   module Standoc
@@ -55,119 +56,30 @@ module Asciidoctor
         end
       end
 
-      # extending localities to cover ISO referencing
-      LOCALITY_REGEX_STR = <<~REGEXP.freeze
-        ^((?<locality>section|clause|part|paragraph|chapter|page|
-                      table|annex|figure|example|note|formula|list|time|anchor|
-                      locality:[^ \\t\\n\\r:,;=]+)(\\s+|=)
-               (?<ref>[^"][^ \\t\\n,:-]*|"[^"]+")
-                 (-(?<to>[^"][^ \\t\\n,:-]*|"[^"]"))?|
-          (?<locality2>whole|locality:[^ \\t\\n\\r:,;=]+))(?<punct>[,:;]?)\\s*
-         (?<text>.*)$
-      REGEXP
-      LOCALITY_RE = Regexp.new(LOCALITY_REGEX_STR.gsub(/\s/, ""),
-                               Regexp::IGNORECASE | Regexp::MULTILINE)
-
-      def tq(text)
-        text.sub(/^"/, "").sub(/"$/, "")
-      end
-
-      def extract_localities(elem)
-        f = elem&.children&.first or return
-        f.text? or return
-        head = f.remove.text
-        tail = elem&.children&.remove
-        extract_localities1(elem, head)
-        tail and elem << tail
-      end
-
-      def extract_localities1(elem, text)
-        b = elem.add_child("<localityStack/>").first if LOCALITY_RE.match text
-        while (m = LOCALITY_RE.match text)
-          ref = m[:ref] ? "<referenceFrom>#{tq m[:ref]}</referenceFrom>" : ""
-          refto = m[:to] ? "<referenceTo>#{tq m[:to]}</referenceTo>" : ""
-          b.add_child("<locality type='#{locality_label(m)}'>#{ref}#{refto}"\
-                      "</locality>")
-          text = m[:text]
-          b = elem.add_child("<localityStack/>").first if m[:punct] == ";"
-        end
-        elem.add_child(text) if text
-      end
-
-      def locality_label(match)
-        loc = match[:locality] || match[:locality2]
-        /^locality:/.match?(loc) ? loc : loc&.downcase
-      end
-
-      def xref_to_eref(elem)
-        elem["bibitemid"] = elem["target"]
-        unless elem["citeas"] = @anchors&.dig(elem["target"], :xref)
-          @internal_eref_namespaces.include?(elem["type"]) or
-            @log.add("Crossreferences", elem,
-                     "#{elem['target']} does not have a corresponding "\
-                     "anchor ID in the bibliography!")
-        end
-        elem.delete("target")
-        extract_localities(elem) unless elem.children.empty?
-      end
-
-      def xref_cleanup(xmldoc)
-        xmldoc.xpath("//xref").each do |x|
-          /:/.match(x["target"]) and xref_to_internal_eref(x)
-          next unless x.name == "xref"
-
-          if refid? x["target"]
-            x.name = "eref"
-            xref_to_eref(x)
-          else x.delete("type")
-          end
-        end
-      end
-
-      def xref_to_internal_eref(elem)
-        a = elem["target"].split(":", 3)
-        unless a.size < 2 || a[0].empty? || a[1].empty?
-          elem["target"] = "#{a[0]}_#{a[1]}"
-          a.size > 2 and
-            elem.children = %{anchor="#{a[2..-1].join}",#{elem&.children&.text}}
-          elem["type"] = a[0]
-          @internal_eref_namespaces << a[0]
-          elem.name = "eref"
-          xref_to_eref(elem)
-        end
-      end
-
-      def quotesource_cleanup(xmldoc)
-        xmldoc.xpath("//quote/source | //terms/source").each do |x|
-          xref_to_eref(x)
+      def concept_cleanup(xmldoc)
+        xmldoc.xpath("//concept[not(termxref)]").each do |x|
+          term = x.at("./refterm")
+          term&.remove if term&.text&.empty?
+          concept_cleanup1(x)
         end
       end
 
-      def origin_cleanup(xmldoc)
-        xmldoc.xpath("//origin/concept[termref]").each do |x|
-          t = x.at("./termref")
-          x.replace(t)
-        end
-        xmldoc.xpath("//origin").each do |x|
-          x["citeas"] = @anchors&.dig(x["bibitemid"], :xref) or
-            @log.add("Crossreferences", x,
-                     "#{x['bibitemid']} does not have a corresponding anchor "\
-                     "ID in the bibliography!")
-          extract_localities(x) unless x.children.empty?
+      def concept_cleanup1(elem)
+        elem.children.remove if elem&.children&.text&.strip&.empty?
+        key_extract_locality(elem)
+        if /:/.match?(elem["key"]) then concept_termbase_cleanup(elem)
+        elsif refid? elem["key"] then concept_eref_cleanup(elem)
+        else concept_xref_cleanup(elem)
         end
+        elem.delete("key")
       end
 
-      def concept_cleanup(xmldoc)
-        xmldoc.xpath("//concept[not(termxref)]").each do |x|
+      def related_cleanup(xmldoc)
+        xmldoc.xpath("//related[not(termxref)]").each do |x|
           term = x.at("./refterm")
-          term&.remove if term&.text&.empty?
-          x.children.remove if x&.children&.text&.strip&.empty?
-          key_extract_locality(x)
-          if /:/.match?(x["key"]) then concept_termbase_cleanup(x)
-          elsif refid? x["key"] then concept_eref_cleanup(x)
-          else concept_xref_cleanup(x)
-          end
-          x.delete("key")
+          term.replace("<preferred>#{term_expr(term.children.to_xml)}"\
+                       "</preferred>")
+          concept_cleanup1(x)
         end
       end
 
@@ -214,6 +126,7 @@ module Asciidoctor
       def anchor_cleanup(elem)
         anchor_cleanup1(elem)
         xreftarget_cleanup(elem)
+        contenthash_id_cleanup(elem)
       end
 
       def anchor_cleanup1(elem)
@@ -239,6 +152,29 @@ module Asciidoctor
           end
         end
       end
+
+      def guid?(str)
+        /^_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+          .match?(str)
+      end
+
+      def contenthash_id_cleanup(doc)
+        ids = doc.xpath("//*[@id]").each_with_object({}) do |x, m|
+          next unless guid?(x["id"])
+
+          m[x["id"]] = contenthash(x)
+          x["id"] = m[x["id"]]
+        end
+        [%w(review from), %(review to), %(callout target), %(eref bibitemid),
+         %(citation bibitemid), %(xref target), %(xref to)].each do |a|
+          doc.xpath("//#{a[0]}").each { |x| ids[a[1]] and x[a[1]] = ids[a[1]] }
+        end
+      end
+
+      def contenthash(elem)
+        Digest::MD5.hexdigest("#{elem.path}////#{elem.text}")
+          .sub(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "_\\1-\\2-\\3-\\4-\\5")
+      end
     end
   end
 end

data/lib/asciidoctor/standoc/cleanup_maths.rb

@@ -69,13 +69,12 @@ module Asciidoctor
         return false if char.length > 1
 
         if /\p{Greek}/.match?(char)
-          /\p{Lower}/.match(char) && !mathml_mi_italics[:lowergreek] ||
-            /\p{Upper}/.match(char) && !mathml_mi_italics[:uppergreek]
+          (/\p{Lower}/.match(char) && !mathml_mi_italics[:lowergreek]) ||
+            (/\p{Upper}/.match(char) && !mathml_mi_italics[:uppergreek])
         elsif /\p{Latin}/.match?(char)
-          /\p{Lower}/.match(char) && !mathml_mi_italics[:lowerroman] ||
-            /\p{Upper}/.match(char) && !mathml_mi_italics[:upperroman]
-        else
-          false
+          (/\p{Lower}/.match(char) && !mathml_mi_italics[:lowerroman]) ||
+            (/\p{Upper}/.match(char) && !mathml_mi_italics[:upperroman])
+        else false
         end
       end
 

data/lib/asciidoctor/standoc/cleanup_ref.rb

@@ -84,6 +84,11 @@ module Asciidoctor
         biblio_reorder(xmldoc)
         biblio_nested(xmldoc)
         biblio_renumber(xmldoc)
+        biblio_no_ext(xmldoc)
+      end
+
+      def biblio_no_ext(xmldoc)
+        xmldoc.xpath("//bibitem/ext").each(&:remove)
       end
 
       def biblio_nested(xmldoc)

data/lib/asciidoctor/standoc/cleanup_reqt.rb

@@ -72,7 +72,7 @@ module Asciidoctor
       def requirement_metadata(xmldoc)
         xmldoc.xpath(REQRECPER).each do |r|
           dl = r&.at("./dl[@metadata = 'true']")&.remove or next
-          requirement_metadata1(r, dl)
+          requirement_metadata1(r, dl, r.at("./title"))
         end
       end
 
@@ -80,39 +80,20 @@ module Asciidoctor
         %w(label subject inherit)
       end
 
-      def requirement_metadata1(reqt, dlist)
-        unless ins = reqt.at("./title")
+      def requirement_metadata1(reqt, dlist, ins)
+        unless ins
           reqt.children.first.previous = " "
           ins = reqt.children.first
         end
         %w(obligation model type).each do |a|
-          reqt_dl_to_attrs(reqt, dlist, a)
+          dl_to_attrs(reqt, dlist, a)
         end
         requirement_metadata1_tags.each do |a|
-          ins = reqt_dl_to_elems(ins, reqt, dlist, a)
+          ins = dl_to_elems(ins, reqt, dlist, a)
         end
         reqt_dl_to_classif(ins, reqt, dlist)
       end
 
-      def reqt_dl_to_attrs(reqt, dlist, name)
-        e = dlist.at("./dt[text()='#{name}']") or return
-        val = e.at("./following::dd/p") || e.at("./following::dd") or return
-        reqt[name] = val.text
-      end
-
-      def reqt_dl_to_elems(ins, reqt, dlist, name)
-        if a = reqt.at("./#{name}[last()]")
-          ins = a
-        end
-        dlist.xpath("./dt[text()='#{name}']").each do |e|
-          val = e.at("./following::dd/p") || e.at("./following::dd")
-          val.name = name
-          ins.next = val
-          ins = ins.next
-        end
-        ins
-      end
-
       def reqt_dl_to_classif(ins, reqt, dlist)
         if a = reqt.at("./classification[last()]") then ins = a end
         dlist.xpath("./dt[text()='classification']").each do |e|

data/lib/asciidoctor/standoc/cleanup_section_names.rb

@@ -78,12 +78,12 @@ module Asciidoctor
       def sections_variant_title_cleanup(xml)
         path = SECTION_CONTAINERS.map { |x| "./ancestor::#{x}" }.join(" | ")
         xml.xpath("//p[@variant_title]").each do |p|
+          p.name = "variant-title"
+          p.delete("id")
+          p.delete("variant_title")
           p.xpath("(#{path})[last()]").each do |sect|
-            p.name = "variant-title"
-            p.delete("id")
-            if ins = sect.at("./title") then ins.next = p
-            else sect.children.first.previous = p
-            end
+            ins = sect.at("./title") and ins.next = p or
+              sect.children.first.previous = p
           end
         end
       end

data/lib/asciidoctor/standoc/cleanup_symbols.rb

@@ -0,0 +1,48 @@
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      # Indices sort after letter but before any following
+      # letter (x, x_m, x_1, xa); we use colon to force that sort order.
+      # Numbers sort *after* letters; we use thorn to force that sort order.
+      def symbol_key(sym)
+        key = sym.dup
+        key.traverse do |n|
+          n.name == "math" and
+            n.replace(grkletters(MathML2AsciiMath.m2a(n.to_xml)))
+        end
+        ret = Nokogiri::XML(key.to_xml)
+        HTMLEntities.new.decode(ret.text.downcase)
+          .gsub(/[\[\]{}<>()]/, "").gsub(/\s/m, "")
+          .gsub(/[[:punct:]]|[_^]/, ":\\0").gsub(/`/, "")
+          .gsub(/[0-9]+/, "þ\\0")
+      end
+
+      def grkletters(text)
+        text.gsub(/\b(alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|
+                      lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|
+                      psi|omega)\b/xi, "&\\1;")
+      end
+
+      def extract_symbols_list(dlist)
+        dl_out = []
+        dlist.xpath("./dt | ./dd").each do |dtd|
+          if dtd.name == "dt"
+            dl_out << { dt: dtd.remove, key: symbol_key(dtd) }
+          else
+            dl_out.last[:dd] = dtd.remove
+          end
+        end
+        dl_out
+      end
+
+      def symbols_cleanup(docxml)
+        docxml.xpath("//definitions/dl").each do |dl|
+          dl_out = extract_symbols_list(dl)
+          dl_out.sort! { |a, b| a[:key] <=> b[:key] || a[:dt] <=> b[:dt] }
+          dl.children = dl_out.map { |d| d[:dt].to_s + d[:dd].to_s }.join("\n")
+        end
+        docxml
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/cleanup_table.rb

@@ -0,0 +1,68 @@
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def dl1_table_cleanup(xmldoc)
+        q = "//table/following-sibling::*[1][self::dl]"
+        xmldoc.xpath(q).each do |s|
+          s["key"] == "true" and s.previous_element << s.remove
+        end
+      end
+
+      # move Key dl after table footer
+      def dl2_table_cleanup(xmldoc)
+        q = "//table/following-sibling::*[1][self::p]"
+        xmldoc.xpath(q).each do |s|
+          if s.text =~ /^\s*key[^a-z]*$/i && s&.next_element&.name == "dl"
+            s.next_element["key"] = "true"
+            s.previous_element << s.next_element.remove
+            s.remove
+          end
+        end
+      end
+
+      def insert_thead(table)
+        thead = table.at("./thead")
+        return thead unless thead.nil?
+
+        if tname = table.at("./name")
+          thead = tname.add_next_sibling("<thead/>").first
+          return thead
+        end
+        table.children.first.add_previous_sibling("<thead/>").first
+      end
+
+      def header_rows_cleanup(xmldoc)
+        xmldoc.xpath("//table[@headerrows]").each do |s|
+          thead = insert_thead(s)
+          (thead.xpath("./tr").size...s["headerrows"].to_i).each do
+            row = s.at("./tbody/tr")
+            row.parent = thead
+          end
+          thead.xpath(".//td").each { |n| n.name = "th" }
+          s.delete("headerrows")
+        end
+      end
+
+      def table_cleanup(xmldoc)
+        dl1_table_cleanup(xmldoc)
+        dl2_table_cleanup(xmldoc)
+        notes_table_cleanup(xmldoc)
+        header_rows_cleanup(xmldoc)
+      end
+
+      # move notes into table
+      def notes_table_cleanup(xmldoc)
+        nomatches = false
+        until nomatches
+          nomatches = true
+          xmldoc.xpath("//table/following-sibling::*[1]"\
+                       "[self::note[not(@keep-separate = 'true')]]").each do |n|
+            n.delete("keep-separate")
+            n.previous_element << n.remove
+            nomatches = false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/cleanup_terms.rb

@@ -1,19 +1,9 @@
 require_relative "term_lookup_cleanup"
+require_relative "cleanup_terms_designations"
 
 module Asciidoctor
   module Standoc
     module Cleanup
-      def termdef_stem_cleanup(xmldoc)
-        xmldoc.xpath("//term/p/stem").each do |a|
-          if a.parent.elements.size == 1 # para contains just a stem expression
-            t = Nokogiri::XML::Element.new("admitted", xmldoc)
-            parent = a.parent
-            t.children = a.remove
-            parent.replace(t)
-          end
-        end
-      end
-
       def termdomain_cleanup(xmldoc)
         xmldoc.xpath("//p/domain").each do |a|
           prev = a.parent.previous
@@ -22,43 +12,53 @@ module Asciidoctor
       end
 
       def termdomain1_cleanup(xmldoc)
-        xmldoc.xpath("//domain").each do |d|
-          defn = d.at("../definition") and
-            defn.previous = d.remove
+        xmldoc.xpath("//term").each do |t|
+          d = t.xpath("./domain | ./subject | ./usageinfo").last or next
+          defn = d.at("../definition") and defn.previous = d.remove
         end
       end
 
       def termdefinition_cleanup(xmldoc)
+        generate_termdefinitions(xmldoc)
+        split_termdefinitions(xmldoc)
+      end
+
+      def generate_termdefinitions(xmldoc)
         xmldoc.xpath("//term[not(definition)]").each do |d|
-          first_child = d.at("./p | ./figure | ./formula") || next
+          first_child = d.at("./p | ./figure | ./formula | ./table") || next
           t = Nokogiri::XML::Element.new("definition", xmldoc)
           first_child.replace(t)
           t << first_child.remove
-          d.xpath("./p | ./figure | ./formula").each { |n| t << n.remove }
+          d.xpath("./p | ./figure | ./formula | ./table").each { |n| t << n.remove }
         end
       end
 
-      def termdef_unnest_cleanup(xmldoc)
-        # release termdef tags from surrounding paras
-        nodes = xmldoc.xpath("//p/admitted | //p/deprecates")
-        while !nodes.empty?
-          nodes[0].parent.replace(nodes[0].parent.children)
-          nodes = xmldoc.xpath("//p/admitted | //p/deprecates")
+      def split_termdefinitions(xmldoc)
+        xmldoc.xpath("//definition").each do |d|
+          n = d.children.first.add_previous_sibling("<nonverbalrepresentation/>").first
+          v = d.children.first.add_previous_sibling("<verbaldefinition/>").first
+          nonverb = false
+          d.elements.each do |e|
+            case e.name
+            when "nonverbalrepresentation", "verbaldefinition" then next
+            when "figure", "table", "formula"
+              n << e.remove
+              nonverb = true
+            when "termsource"
+              (nonverb ? n : v) << e.remove
+            else v << e.remove
+            end
+          end
         end
       end
 
-      def termdef_subclause_cleanup(xmldoc)
-        xmldoc.xpath("//terms[terms]").each { |t| t.name = "clause" }
-      end
-
       def termdocsource_cleanup(xmldoc)
         f = xmldoc.at("//preface | //sections")
-        xmldoc.xpath("//termdocsource").each do |s|
-          f.previous = s.remove
-        end
+        xmldoc.xpath("//termdocsource").each { |s| f.previous = s.remove }
       end
 
       def term_children_cleanup(xmldoc)
+        xmldoc.xpath("//terms[terms]").each { |t| t.name = "clause" }
         xmldoc.xpath("//term").each do |t|
           %w(termnote termexample termsource).each do |w|
             t.xpath("./#{w}").each { |n| t << n.remove }
@@ -75,69 +75,29 @@ module Asciidoctor
       end
 
       def termnote_example_cleanup(xmldoc)
-        xmldoc.xpath("//termnote[not(ancestor::term)]").each do |x|
-          x.name = "note"
+        %w(note example).each do |w|
+        xmldoc.xpath("//term#{w}[not(ancestor::term)]").each do |x|
+          x.name = w
         end
-        xmldoc.xpath("//termexample[not(ancestor::term)]").each do |x|
-          x.name = "example"
         end
       end
 
       def termdef_cleanup(xmldoc)
+        termdef_unnest_cleanup(xmldoc)
         Asciidoctor::Standoc::TermLookupCleanup.new(xmldoc, @log).call
+        term_nonverbal_designations(xmldoc)
+        term_dl_to_metadata(xmldoc)
+        term_termsource_to_designation(xmldoc)
+        term_designation_reorder(xmldoc)
         termdef_from_termbase(xmldoc)
-        termdef_unnest_cleanup(xmldoc)
         termdef_stem_cleanup(xmldoc)
         termdomain_cleanup(xmldoc)
         termdefinition_cleanup(xmldoc)
         termdomain1_cleanup(xmldoc)
         termnote_example_cleanup(xmldoc)
-        termdef_subclause_cleanup(xmldoc)
         term_children_cleanup(xmldoc)
         termdocsource_cleanup(xmldoc)
       end
-
-      # Indices sort after letter but before any following
-      # letter (x, x_m, x_1, xa); we use colon to force that sort order.
-      # Numbers sort *after* letters; we use thorn to force that sort order.
-      def symbol_key(sym)
-        key = sym.dup
-        key.traverse do |n|
-          next unless n.name == "math"
-
-          n.replace(grkletters(MathML2AsciiMath.m2a(n.to_xml)))
-        end
-        ret = Nokogiri::XML(key.to_xml)
-        HTMLEntities.new.decode(ret.text.downcase)
-          .gsub(/[\[\]{}<>()]/, "").gsub(/\s/m, "")
-          .gsub(/[[:punct:]]|[_^]/, ":\\0").gsub(/`/, "")
-          .gsub(/[0-9]+/, "þ\\0")
-      end
-
-      def grkletters(x)
-        x.gsub(/\b(alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega)\b/i, "&\\1;")
-      end
-
-      def extract_symbols_list(dlist)
-        dl_out = []
-        dlist.xpath("./dt | ./dd").each do |dtd|
-          if dtd.name == "dt"
-            dl_out << { dt: dtd.remove, key: symbol_key(dtd) }
-          else
-            dl_out.last[:dd] = dtd.remove
-          end
-        end
-        dl_out
-      end
-
-      def symbols_cleanup(docxml)
-        docxml.xpath("//definitions/dl").each do |dl|
-          dl_out = extract_symbols_list(dl)
-          dl_out.sort! { |a, b| a[:key] <=> b[:key] || a[:dt] <=> b[:dt] }
-          dl.children = dl_out.map { |d| d[:dt].to_s + d[:dd].to_s }.join("\n")
-        end
-        docxml
-      end
     end
   end
 end