metanorma-standoc 1.10.8 → 1.11.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2cc836755aed6cfff989fdcbc9cf8123ccfda29418247d93fdd75ba71660cee7
-  data.tar.gz: d1c051429283a6e4153a6a3453b839786561c0975c2acda0586cb0ca787ae26a
+  metadata.gz: 4c272a7b64955264d820737284d46d47a03d7baaf56d0a365396a5a2cb5455ac
+  data.tar.gz: b04e30dd2633c21853ff81aaa14ddff65ddca564e4878a1914507ba7f4d43294
 SHA512:
-  metadata.gz: 1e17a3351bf46679b587a82498d5f58d97e43743bd2e6906c929aa8dcbb8ca29fdd6e38acb82252375b40e5fff520f7d6a001b023c9c79681ad61fea949c0799
-  data.tar.gz: 01dd1e74b7990b44c526616611155067c0725b0b0bcaeebe9d728c341d26acdab64c2c5be7519b22b94fd641015aec504c333c3b3da8cf6067c19999c20ab0ff
+  metadata.gz: 00117f839c229ac456a92d59ea8d7d17fbdb2dc680098126fc77c67696ae1c84cd70e3785a3b9e15c055588678a8d4a27fa1d2069431b38fa83c25fe20885d1d
+  data.tar.gz: 78bf3e8ef72cc04f40c3a98cfbf29e14176f04ff1cbade1f299c9a3c284e303d481574f7f1b07ba7fa8cd769a32f6d05b745f550c43ea648c0d354ef3ae8d5ad

data/Rakefile

@@ -1,6 +1,6 @@
 require "bundler/gem_tasks"
 require "rspec/core/rake_task"
-require 'isodoc/gem_tasks'
+require "isodoc/gem_tasks"
 
 IsoDoc::GemTasks.install
 RSpec::Core::RakeTask.new(:spec)

data/lib/asciidoctor/standoc/base.rb

@@ -14,6 +14,7 @@ module Asciidoctor
     module Base
       XML_ROOT_TAG = "standard-document".freeze
       XML_NAMESPACE = "https://www.metanorma.org/ns/standoc".freeze
+      FONTS_MANIFEST = "fonts-manifest".freeze
 
       def xml_root_tag
         self.class::XML_ROOT_TAG
@@ -38,7 +39,7 @@ module Asciidoctor
           scripts: node.attr("scripts"),
           scripts_override: node.attr("scripts-override"),
           scripts_pdf: node.attr("scripts-pdf"),
-          datauriimage: node.attr("data-uri-image"),
+          datauriimage: node.attr("data-uri-image") != "false",
           htmltoclevels: node.attr("htmltoclevels") || node.attr("toclevels"),
           doctoclevels: node.attr("doctoclevels") || node.attr("toclevels"),
           break_up_urls_in_tables: node.attr("break-up-urls-in-tables"),
@@ -85,9 +86,9 @@ module Asciidoctor
           aligncrosselements: node.attr("align-cross-elements"),
         }
 
-        if font_manifest_file = node.attr("mn2pdf-font-manifest-file")
+        if fonts_manifest = node.attr(FONTS_MANIFEST)
           attrs[IsoDoc::XslfoPdfConvert::MN2PDF_OPTIONS] = {
-            IsoDoc::XslfoPdfConvert::MN2PDF_FONT_MANIFEST => font_manifest_file,
+            IsoDoc::XslfoPdfConvert::MN2PDF_FONT_MANIFEST => fonts_manifest,
           }
         end
 
@@ -127,7 +128,7 @@ module Asciidoctor
         @sourcecode_markup_end = node.attr("sourcecode-markup-end") || "}}}"
         @bibdb = nil
         @seen_headers = []
-        @datauriimage = node.attr("data-uri-image")
+        @datauriimage = node.attr("data-uri-image") != "false"
         @boilerplateauthority = node.attr("boilerplate-authority")
         @sourcecode_markup_start = node.attr("sourcecode-markup-start") || "{{{"
         @sourcecode_markup_end = node.attr("sourcecode-markup-end") || "}}}"

data/lib/asciidoctor/standoc/cleanup.rb

@@ -9,6 +9,7 @@ require_relative "./cleanup_ref_dl"
 require_relative "./cleanup_boilerplate"
 require_relative "./cleanup_section"
 require_relative "./cleanup_terms"
+require_relative "./cleanup_symbols"
 require_relative "./cleanup_xref"
 require_relative "./cleanup_inline"
 require_relative "./cleanup_amend"
@@ -41,6 +42,7 @@ module Asciidoctor
         symbols_cleanup(xmldoc)
         xref_cleanup(xmldoc)
         concept_cleanup(xmldoc)
+        related_cleanup(xmldoc)
         origin_cleanup(xmldoc)
         bookmark_cleanup(xmldoc)
         termdef_cleanup(xmldoc)
@@ -73,7 +75,8 @@ module Asciidoctor
         %w{status language script version author name callout phone email
            street city state country postcode identifier referenceFrom surname
            referenceTo docidentifier docnumber prefix initial addition forename
-           title draft secretariat title-main title-intro title-part}.freeze
+           title draft secretariat title-main title-intro title-part
+           verbaldefinition nonverbalrepresentation}.freeze
 
       # it seems Nokogiri::XML is treating the content of <script> as cdata,
       # because of its use in HTML. Bad nokogiri. Undoing that, since we use
@@ -83,7 +86,9 @@ module Asciidoctor
       end
 
       def empty_element_cleanup(xmldoc)
-        xmldoc.xpath("//" + TEXT_ELEMS.join(" | //")).each do |x|
+        xmldoc.xpath("//#{TEXT_ELEMS.join(' | //')}").each do |x|
+          next if x.name == "name" && x.parent.name == "expression"
+
           x.remove if x.children.empty?
         end
       end
@@ -108,19 +113,23 @@ module Asciidoctor
             n.name != "variant" && (!n.text? || !n.text.gsub(/\s/, "").empty?)
           end
 
-          c.xpath("./variant").each do |n|
-            if n.at_xpath("preceding-sibling::node()"\
-                          "[not(self::text()[not(normalize-space())])][1]"\
-                          "[self::variantwrap]")
-              n.previous_element << n
-            else
-              n.replace("<variantwrap/>").first << n
-            end
-          end
+          variant_cleanup1(c)
         end
         xmldoc.xpath("//variantwrap").each { |n| n.name = "variant" }
       end
 
+      def variant_cleanup1(elem)
+        elem.xpath("./variant").each do |n|
+          if n.at_xpath("preceding-sibling::node()"\
+                        "[not(self::text()[not(normalize-space())])][1]"\
+                        "[self::variantwrap]")
+            n.previous_element << n
+          else
+            n.replace("<variantwrap/>").first << n
+          end
+        end
+      end
+
       def variant_space_cleanup(xmldoc)
         xmldoc.xpath("//*[variant]").each do |c|
           if c&.next&.text? && c&.next&.next&.name == "variant"

data/lib/asciidoctor/standoc/cleanup_inline.rb

@@ -60,13 +60,26 @@ module Asciidoctor
         xmldoc.xpath("//concept[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")
+          concept_cleanup1(x)
+        end
+      end
+
+      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 related_cleanup(xmldoc)
+        xmldoc.xpath("//related[not(termxref)]").each do |x|
+          term = x.at("./refterm")
+          term.replace("<preferred>#{term_expr(term.children.to_xml)}"\
+                       "</preferred>")
+          concept_cleanup1(x)
         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_reqt.rb

@@ -86,33 +86,14 @@ module Asciidoctor
           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_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_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

data/lib/asciidoctor/standoc/cleanup_terms_designations.rb

@@ -0,0 +1,162 @@
+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
+            parent = a.parent
+            parent.replace("<admitted>#{term_expr(a.to_xml)}</admitted>")
+          end
+        end
+        xmldoc.xpath("//term//expression/name[stem]").each do |n|
+          n.parent.name = "letter-symbol"
+        end
+      end
+
+      # release termdef tags from surrounding paras
+      def termdef_unnest_cleanup(xmldoc)
+        desgn = "//p/admitted | //p/deprecates | //p/preferred | //p//related"
+        nodes = xmldoc.xpath(desgn)
+        while !nodes.empty?
+          nodes[0].parent.replace(nodes[0].parent.children)
+          nodes = xmldoc.xpath(desgn)
+        end
+      end
+
+      def term_dl_to_metadata(xmldoc)
+        xmldoc.xpath("//term[dl[@metadata = 'true']]").each do |t|
+          t.xpath("./dl[@metadata = 'true']").each do |dl|
+            prev = dl_to_designation(dl) or next
+            term_dl_to_designation_metadata(prev, dl)
+            term_dl_to_term_metadata(prev, dl)
+            term_dl_to_expression_metadata(prev, dl)
+            dl.remove
+          end
+        end
+      end
+
+      def term_dl_to_term_metadata(prev, dlist)
+        return unless prev.name == "preferred" &&
+          prev.at("./preceding-sibling::preferred").nil?
+
+        ins = term_element_insert_point(prev)
+        %w(domain subject usageinfo).each do |a|
+          ins = dl_to_elems(ins, prev.parent, dlist, a)
+        end
+      end
+
+      def term_dl_to_designation_metadata(prev, dlist)
+        %w(absent geographicArea).each { |a| dl_to_attrs(related2pref(prev), dlist, a) }
+      end
+
+      def term_element_insert_point(prev)
+        ins = prev
+        while %w(preferred admitted deprecates related domain dl)
+            .include? ins&.next_element&.name
+          ins = ins.next_element
+        end
+        ins
+      end
+
+      def term_dl_to_expression_metadata(prev, dlist)
+        %w(language script type isInternational).each do |a|
+          dl_to_attrs(prev, dlist, a)
+        end
+        %w(abbreviationType pronunciation).reverse.each do |a|
+          dl_to_elems(prev.at("./expression/name"), prev, dlist, a)
+        end
+        g = dlist.at("./dt[text()='grammar']/following::dd//dl") and
+          term_dl_to_expression_grammar(prev, g)
+        term_to_letter_symbol(prev, dlist)
+      end
+
+      def term_dl_to_expression_grammar(prev, dlist)
+        prev.at(".//expression") or return
+        prev.at(".//expression") << "<grammar><sentinel/></grammar>"
+        %w(gender isPreposition isParticiple isAdjective isAdverb isNoun
+           grammarValue).reverse.each do |a|
+          dl_to_elems(prev.at(".//expression/grammar/*"), prev.elements.last,
+                      dlist, a)
+        end
+        term_dl_to_designation_gender(prev)
+      end
+
+      def term_dl_to_designation_gender(prev)
+        gender = prev.at(".//expression/grammar/gender")
+        /,/.match?(gender&.text) and
+          gender.replace(gender.text.split(/,\s*/)
+            .map { |x| "<gender>#{x}</gender>" }.join)
+        prev.at(".//expression/grammar/sentinel").remove
+      end
+
+      def term_to_letter_symbol(prev, dlist)
+        ls = dlist.at("./dt[text()='letter-symbol']/following::dd/p")
+        return unless ls&.text == "true"
+
+        prev.at(".//expression").name = "letter-symbol"
+      end
+
+      def dl_to_designation(dlist)
+        prev = dlist.previous_element
+        unless %w(preferred admitted deprecates related).include? prev&.name
+          @log.add("AsciiDoc Input", dlist, "Metadata definition list does "\
+                                            "not follow a term designation")
+          return nil
+        end
+        prev
+      end
+
+      def term_nonverbal_designations(xmldoc)
+        xmldoc.xpath("//term/preferred | //term/admitted | //term/deprecates")
+          .each do |d|
+          d.text.strip.empty? or next
+          n = d.next_element
+          if %w(formula figure).include?(n&.name)
+            term_nonverbal_designations1(d, n)
+          else d.at("./expression/name") or
+            d.children = term_expr("")
+          end
+        end
+      end
+
+      def term_nonverbal_designations1(desgn, elem)
+        desgn = related2pref(desgn)
+        if elem.name == "figure"
+          elem.at("./name").remove
+          desgn.children =
+            "<graphical-symbol>#{elem.remove.to_xml}</graphical-symbol>"
+        else
+          desgn.children = term_expr(elem.at("./stem").to_xml)
+          elem.remove
+        end
+      end
+
+      def term_termsource_to_designation(xmldoc)
+        xmldoc.xpath("//term/termsource").each do |t|
+          p = t.previous_element
+          while %w(domain subject usageinfo).include? p&.name
+            p = p.previous_element
+          end
+          %w(preferred admitted deprecates related).include?(p&.name) or
+            next
+          related2pref(p) << t.remove
+        end
+      end
+
+      def term_designation_reorder(xmldoc)
+        xmldoc.xpath("//term").each do |t|
+          %w(preferred admitted deprecates related)
+            .each_with_object([]) do |tag, m|
+            t.xpath("./#{tag}").each { |x| m << x.remove }
+          end.reverse.each do |x|
+            t.children.first.previous = x
+          end
+        end
+      end
+
+      def related2pref(elem)
+        elem.name == "related" ? elem = elem.at("./preferred") : elem
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/converter.rb

@@ -28,8 +28,10 @@ module Asciidoctor
         preprocessor Metanorma::Plugin::Lutaml::LutamlPreprocessor
         preprocessor Metanorma::Plugin::Lutaml::LutamlUmlAttributesTablePreprocessor
         preprocessor Metanorma::Plugin::Lutaml::LutamlUmlDatamodelDescriptionPreprocessor
+        inline_macro Asciidoctor::Standoc::PreferredTermInlineMacro
         inline_macro Asciidoctor::Standoc::AltTermInlineMacro
         inline_macro Asciidoctor::Standoc::DeprecatedTermInlineMacro
+        inline_macro Asciidoctor::Standoc::RelatedTermInlineMacro
         inline_macro Asciidoctor::Standoc::DomainTermInlineMacro
         inline_macro Asciidoctor::Standoc::InheritInlineMacro
         inline_macro Asciidoctor::Standoc::HTML5RubyMacro

data/lib/asciidoctor/standoc/inline.rb

@@ -170,8 +170,10 @@ module Asciidoctor
           else
             case node.role
               # the following three are legacy, they are now handled by macros
-            when "alt" then xml.admitted { |a| a << node.text }
-            when "deprecated" then xml.deprecates { |a| a << node.text }
+            when "alt"
+              term_designation(xml, node, "admitted", node.text)
+            when "deprecated"
+              term_designation(xml, node, "deprecates", node.text)
             when "domain" then xml.domain { |a| a << node.text }
 
             when "strike" then xml.strike { |s| s << node.text }
@@ -209,7 +211,7 @@ module Asciidoctor
       def inline_image(node)
         noko do |xml|
           xml.image **image_attributes(node)
-        end.join("")
+        end.join
       end
 
       def inline_indexterm(node)
@@ -218,8 +220,8 @@ module Asciidoctor
           terms = (node.attr("terms") || [node.text]).map { |x| xml_encode(x) }
           xml.index do |i|
             i.primary { |x| x << terms[0] }
-            a = terms.dig(1) and i.secondary { |x| x << a }
-            a = terms.dig(2) and i.tertiary { |x| x << a }
+            a = terms[1] and i.secondary { |x| x << a }
+            a = terms[2] and i.tertiary { |x| x << a }
           end
         end.join
       end