metanorma-standoc 1.10.8 → 1.11.2

data/lib/asciidoctor/standoc/ref.rb

@@ -22,37 +22,44 @@ module Asciidoctor
         { id: match[:anchor], type: "standard" }
       end
 
-      def isorefrender1(bib, match, yr, allp = "")
+      def isorefrender1(bib, match, year, allp = "")
         bib.title(**plaintxt) { |i| i << ref_normalise(match[:text]) }
         docid(bib, match[:usrlbl]) if match[:usrlbl]
-        docid(bib, id_and_year(match[:code], yr) + allp)
+        docid(bib, id_and_year(match[:code], year) + allp)
         docnumber(bib, match[:code])
       end
 
-      def isorefmatches(xml, match)
+      def isorefmatchescode(match)
         yr = norm_year(match[:year])
-        ref = fetch_ref xml, match[:code], yr,
-                        title: match[:text], usrlbl: match[:usrlbl],
-                        lang: (@lang || :all)
-        return use_my_anchor(ref, match[:anchor]) if ref
-
-        xml.bibitem **attr_code(ref_attributes(match)) do |t|
-          isorefrender1(t, match, yr)
-          yr and t.date **{ type: "published" } do |d|
-            set_date_range(d, yr)
+        { code: match[:code], year: yr, match: match,
+          title: match[:text], usrlbl: match[:usrlbl],
+          lang: (@lang || :all) }
+      end
+
+      def isorefmatchesout(item, xml)
+        if item[:doc] then use_retrieved_relaton(item, xml)
+        else
+          xml.bibitem **attr_code(ref_attributes(item[:ref][:match])) do |t|
+            isorefrender1(t, item[:ref][:match], item[:ref][:year])
+            item[:ref][:year] and t.date **{ type: "published" } do |d|
+              set_date_range(d, item[:ref][:year])
+            end
+            iso_publisher(t, item[:ref][:match][:code])
           end
-          iso_publisher(t, match[:code])
         end
       end
 
-      def isorefmatches2(xml, match)
-        ref = fetch_ref xml, match[:code], nil,
-                        no_year: true, note: match[:fn],
-                        title: match[:text], usrlbl: match[:usrlbl],
-                        lang: (@lang || :all)
-        return use_my_anchor(ref, match[:anchor]) if ref
+      def isorefmatches2code(match)
+        { code: match[:code], no_year: true,
+          note: match[:fn], year: nil, match: match,
+          title: match[:text], usrlbl: match[:usrlbl],
+          lang: (@lang || :all) }
+      end
 
-        isorefmatches2_1(xml, match)
+      def isorefmatches2out(item, xml)
+        if item[:doc] then use_retrieved_relaton(item, xml)
+        else isorefmatches2_1(xml, item[:ref][:match])
+        end
       end
 
       def isorefmatches2_1(xml, match)
@@ -70,16 +77,22 @@ module Asciidoctor
         end
       end
 
-      def isorefmatches3(xml, match)
+      def isorefmatches3code(match)
         yr = norm_year(match[:year])
         hasyr = !yr.nil? && yr != "--"
-        ref = fetch_ref(xml, match[:code], hasyr ? yr : nil,
-                        all_parts: true, no_year: yr == "--",
-                        text: match[:text], usrlbl: match[:usrlbl],
-                        lang: (@lang || :all))
-        return use_my_anchor(ref, match[:anchor]) if ref
-
-        isorefmatches3_1(xml, match, yr, hasyr, ref)
+        { code: match[:code], match: match, yr: yr, hasyr: hasyr,
+          year: hasyr ? yr : nil,
+          all_parts: true, no_year: yr == "--",
+          text: match[:text], usrlbl: match[:usrlbl],
+          lang: (@lang || :all) }
+      end
+
+      def isorefmatches3out(item, xml)
+        if item[:doc] then use_retrieved_relaton(item, xml)
+        else
+          isorefmatches3_1(xml, item[:ref][:match], item[:ref][:yr],
+                           item[:ref][:hasyr], item[:doc])
+        end
       end
 
       def isorefmatches3_1(xml, match, yr, _hasyr, _ref)
@@ -120,56 +133,34 @@ module Asciidoctor
       end
 
       MALFORMED_REF = "no anchor on reference, markup may be malformed: see "\
-        "https://www.metanorma.com/author/topics/document-format/bibliography/ , "\
-        "https://www.metanorma.com/author/iso/topics/markup/#bibliographies".freeze
-
-      def analyse_ref_nofetch(ret)
-        return ret unless m = /^nofetch\((?<id>.+)\)$/.match(ret[:id])
-
-        ret.merge(id: m[:id], nofetch: true)
-      end
-
-      def analyse_ref_repo_path(ret)
-        return ret unless m =
-                            /^(?<type>repo|path):\((?<key>[^,]+),?(?<id>.*)\)$/.match(ret[:id])
-
-        id = m[:id].empty? ? m[:key].sub(%r{^[^/]+/}, "") : m[:id]
-        ret.merge(id: id, type: m[:type], key: m[:key], nofetch: true)
-      end
-
-      def analyse_ref_numeric(ret)
-        return ret unless /^\d+$/.match?(ret[:id])
-
-        ret.merge(numeric: true)
-      end
-
-      # ref id = (usrlbl)code[:-]year
-      # code = nofetch(code) | (repo|path):(key,code) | \[? number \]? | ident
-      def analyse_ref_code(code)
-        ret = { id: code }
-        return ret if code.blank?
-
-        analyse_ref_nofetch(analyse_ref_repo_path(analyse_ref_numeric(ret)))
-      end
+                      "https://www.metanorma.com/author/topics/document-format/bibliography/ , "\
+                      "https://www.metanorma.com/author/iso/topics/markup/#bibliographies".freeze
 
       # TODO: alternative where only title is available
-      def refitem(xml, item, node)
-        m = NON_ISO_REF.match(item) and return refitem1(xml, item, m)
+      def refitemcode(item, node)
+        m = NON_ISO_REF.match(item) and return refitem1code(item, m)
         @log.add("AsciiDoc Input", node, "#{MALFORMED_REF}: #{item}")
-        nil
+        {}
       end
 
-      def refitem1(xml, _item, match)
+      def refitem1code(_item, match)
         code = analyse_ref_code(match[:code])
-        unless code[:id] && code[:numeric] || code[:nofetch]
-          ref = fetch_ref(xml, code[:id],
-                          match.names.include?("year") ? match[:year] : nil,
-                          title: match[:text],
-                          usrlbl: match[:usrlbl], lang: (@lang || :all)) and
-            return use_my_anchor(ref, match[:anchor])
+        if (code[:id] && code[:numeric]) || code[:nofetch]
+          { code: nil, match: match, analyse_code: code }
+        else
+          { code: code[:id], analyse_code: code,
+            year: match.names.include?("year") ? match[:year] : nil,
+            title: match[:text], match: match,
+            usrlbl: match[:usrlbl], lang: (@lang || :all) }
         end
+      end
+
+      def refitemout(item, xml)
+        return nil if item[:ref][:match].nil?
 
-        refitem_render(xml, match, code)
+        item[:doc] or return refitem_render(xml, item[:ref][:match],
+                                            item[:ref][:analyse_code])
+        use_retrieved_relaton(item, xml)
       end
 
       def ref_normalise(ref)
@@ -211,15 +202,50 @@ module Asciidoctor
         [matched, matched2, matched3]
       end
 
-      def reference1(node, item, xml)
+      def reference1code(item, node)
         matched, matched2, matched3 = reference1_matches(item)
         if matched3.nil? && matched2.nil? && matched.nil?
-          refitem(xml, item, node)
-        elsif !matched.nil? then isorefmatches(xml, matched)
-        elsif !matched2.nil? then isorefmatches2(xml, matched2)
-        elsif !matched3.nil? then isorefmatches3(xml, matched3)
+          refitemcode(item, node).merge(process: 0)
+        elsif !matched.nil? then isorefmatchescode(matched).merge(process: 1)
+        elsif !matched2.nil? then isorefmatches2code(matched2).merge(process: 2)
+        elsif !matched3.nil? then isorefmatches3code(matched3).merge(process: 3)
         end
       end
+
+      def reference1out(item, xml)
+        case item[:ref][:process]
+        when 0 then refitemout(item, xml)
+        when 1 then isorefmatchesout(item, xml)
+        when 2 then isorefmatches2out(item, xml)
+        when 3 then isorefmatches3out(item, xml)
+        end
+      end
+
+      def reference_preproc(node)
+        refs = node.items.each_with_object([]) do |b, m|
+          m << reference1code(b.text, node)
+        end
+        results = refs.each_with_index.with_object(Queue.new) do |(ref, i), res|
+          fetch_ref_async(ref.merge(ord: i), i, res)
+        end
+        [refs, results]
+      end
+
+      def reference(node)
+        refs, results = reference_preproc(node)
+        noko do |xml|
+          ret = refs.each.with_object([]) do |_, m|
+            ref, i, doc = results.pop
+            m[i.to_i] = { ref: ref }
+            if doc.is_a?(RelatonBib::RequestError)
+              @log.add("Bibliography", nil, "Could not retrieve #{ref[:code]}: "\
+                                            "no access to online site")
+            else m[i.to_i][:doc] = doc
+            end
+          end
+          ret.each { |b| reference1out(b, xml) }
+        end.join
+      end
     end
   end
 end

data/lib/asciidoctor/standoc/ref_date_id.rb

@@ -26,7 +26,7 @@ module Asciidoctor
       def conditional_date(bib, match, noyr)
         if match.names.include?("year") && !match[:year].nil?
           bib.date(**{ type: "published" }) do |d|
-            noyr and d.on "--" or set_date_range(d, norm_year(match[:year]))
+            (noyr and d.on "--") or set_date_range(d, norm_year(match[:year]))
           end
         end
       end
@@ -57,6 +57,35 @@ module Asciidoctor
       def mn_code(code)
         code.sub(/^\(/, "[").sub(/\).*$/, "]").sub(/^nofetch\((.+)\)$/, "\\1")
       end
+
+      def analyse_ref_nofetch(ret)
+        return ret unless m = /^nofetch\((?<id>.+)\)$/.match(ret[:id])
+
+        ret.merge(id: m[:id], nofetch: true)
+      end
+
+      def analyse_ref_repo_path(ret)
+        return ret unless m =
+                            /^(?<type>repo|path):\((?<key>[^,]+),?(?<id>.*)\)$/.match(ret[:id])
+
+        id = m[:id].empty? ? m[:key].sub(%r{^[^/]+/}, "") : m[:id]
+        ret.merge(id: id, type: m[:type], key: m[:key], nofetch: true)
+      end
+
+      def analyse_ref_numeric(ret)
+        return ret unless /^\d+$/.match?(ret[:id])
+
+        ret.merge(numeric: true)
+      end
+
+      # ref id = (usrlbl)code[:-]year
+      # code = nofetch(code) | (repo|path):(key,code) | \[? number \]? | ident
+      def analyse_ref_code(code)
+        ret = { id: code }
+        return ret if code.blank?
+
+        analyse_ref_nofetch(analyse_ref_repo_path(analyse_ref_numeric(ret)))
+      end
     end
   end
 end

data/lib/asciidoctor/standoc/ref_sect.rb

@@ -9,23 +9,15 @@ module Asciidoctor
         @norm_ref
       end
 
-      def reference(node)
-        noko do |xml|
-          node.items.each { |item| reference1(node, item.text, xml) }
-        end.join
-      end
-
       def bibliography_parse(attrs, xml, node)
-        node.option? "bibitem" and return bibitem_parse(attrs, xml, node)
-        node.attr("style") == "bibliography" or
-          @log.add("AsciiDoc Input", node, "Section not marked up as [bibliography]!")
+        x = biblio_prep(attrs, xml, node) and return x
         @biblio = true
-        xml.references **attr_code(attrs.merge(
-          normative: node.attr("normative") || false)) do |xml_section|
-            xml_section.title { |t| t << node.title }
-            xml_section << node.content
-          end
-          @biblio = false
+        attrs = attrs.merge(normative: node.attr("normative") || false)
+        xml.references **attr_code(attrs) do |xml_section|
+          xml_section.title { |t| t << node.title }
+          xml_section << node.content
+        end
+        @biblio = false
       end
 
       def bibitem_parse(attrs, xml, node)
@@ -33,15 +25,14 @@ module Asciidoctor
         biblio = @biblio
         @biblio = false
         @norm_ref = false
-        clause_parse(attrs, xml, node)
+        ret = clause_parse(attrs, xml, node)
         @biblio = biblio
         @norm_ref = norm_ref
+        ret
       end
 
       def norm_ref_parse(attrs, xml, node)
-        node.option? "bibitem" and return bibitem_parse(attrs, xml, node)
-        node.attr("style") == "bibliography" or
-          @log.add("AsciiDoc Input", node, "Section not marked up as [bibliography]!")
+        x = biblio_prep(attrs, xml, node) and return x
         @norm_ref = true
         attrs = attrs.merge(normative: node.attr("normative") || true)
         xml.references **attr_code(attrs) do |xml_section|
@@ -51,6 +42,17 @@ module Asciidoctor
         @norm_ref = false
       end
 
+      def biblio_prep(attrs, xml, node)
+        if node.option? "bibitem"
+          bibitem_parse(attrs, xml, node)
+        else
+          node.attr("style") == "bibliography" or
+            @log.add("AsciiDoc Input", node,
+                     "Section not marked up as [bibliography]!")
+          nil
+        end
+      end
+
       def global_ievcache_name
         "#{Dir.home}/.iev/cache"
       end
@@ -74,10 +76,20 @@ module Asciidoctor
         xml
       rescue RelatonBib::RequestError
         @log.add("Bibliography", nil, "Could not retrieve #{code}: "\
-                 "no access to online site")
+                                      "no access to online site")
         nil
       end
 
+      def fetch_ref_async(ref, idx, res)
+        if ref[:code].nil? || ref[:no_year] || @bibdb.nil?
+          res << [ref, idx, nil]
+        else
+          @bibdb.fetch_async(ref[:code], ref[:year], ref) do |doc|
+            res << [ref, idx, doc]
+          end
+        end
+      end
+
       def emend_biblio(xml, code, title, usrlbl)
         unless xml.at("/bibitem/docidentifier[not(@type = 'DOI')][text()]")
           @log.add("Bibliography", nil,
@@ -87,10 +99,10 @@ module Asciidoctor
         unless xml.at("/bibitem/title[text()]")
           @log.add("Bibliography", nil,
                    "ERROR: No title retrieved for #{code}")
-          xml.root << "<title>#{title || "(MISSING TITLE)"}</title>"
+          xml.root << "<title>#{title || '(MISSING TITLE)'}</title>"
         end
         usrlbl and xml.at("/bibitem/docidentifier").next =
-          "<docidentifier type='metanorma'>#{mn_code(usrlbl)}</docidentifier>"
+                     "<docidentifier type='metanorma'>#{mn_code(usrlbl)}</docidentifier>"
       end
 
       def smart_render_xml(xml, code, opts)
@@ -104,6 +116,12 @@ module Asciidoctor
         xml.to_xml.sub(/<\?[^>]+>/, "")
       end
 
+      def use_retrieved_relaton(item, xml)
+        xml.parent.add_child(smart_render_xml(item[:doc], item[:ref][:code],
+                                              item[:ref]))
+        use_my_anchor(xml, item[:ref][:match][:anchor])
+      end
+
       def init_bib_caches(node)
         return if @no_isobib
 
@@ -113,7 +131,7 @@ module Asciidoctor
         @bibdb = Relaton::DbCache.init_bib_caches(
           local_cache: local,
           flush_caches: node.attr("flush-caches"),
-          global_cache: global
+          global_cache: global,
         )
       end
 
@@ -128,7 +146,7 @@ module Asciidoctor
             FileUtils.rm_f @iev_localname unless @iev_localname.nil?
           end
         end
-        #@iev = Iev::Db.new(globalname, localname) unless @no_isobib
+        # @iev = Iev::Db.new(globalname, localname) unless @no_isobib
       end
     end
   end

data/lib/asciidoctor/standoc/reqt.rb

@@ -1,5 +1,5 @@
 require "htmlentities"
-require "uri"
+require "uri" if /^2\./.match?(RUBY_VERSION)
 require "mime/types"
 require "base64"
 

data/lib/asciidoctor/standoc/section.rb

@@ -1,4 +1,4 @@
-require "uri"
+require "uri" if /^2\./.match?(RUBY_VERSION)
 require_relative "ref_sect"
 require_relative "terms"
 
@@ -18,7 +18,7 @@ module Asciidoctor
       def sectiontype(node, level = true)
         ret = sectiontype1(node)
         ret1 = sectiontype_streamline(ret)
-        return ret1 if "symbols and abbreviated terms" == ret1
+        return ret1 if ret1 == "symbols and abbreviated terms"
         return nil unless !level || node.level == 1
         return nil if @seen_headers.include? ret
 
@@ -49,7 +49,8 @@ module Asciidoctor
                 script: node.attributes["script"],
                 number: node.attributes["number"],
                 type: node.attributes["type"],
-                annex: (if (node.attr("style") == "appendix" || node.role == "appendix") &&
+                annex: (if (node.attr("style") == "appendix" ||
+                            node.role == "appendix") &&
                           node.level == 1
                           true
                         end),
@@ -84,13 +85,11 @@ module Asciidoctor
           else
             if @term_def then term_def_subclause_parse(a, xml, node)
             elsif @definitions then symbols_parse(a, xml, node)
-            elsif @norm_ref then norm_ref_parse(a, xml, node)
-            elsif @biblio then bibliography_parse(a, xml, node)
-            elsif node.attr("style") == "bibliography" && sectiontype(node, false) == "normative references"
+            elsif @norm_ref ||
+                (node.attr("style") == "bibliography" &&
+                 sectiontype(node, false) == "normative references")
               norm_ref_parse(a, xml, node)
-            elsif node.attr("style") == "bibliography" && sectiontype(node, false) == "bibliography"
-              bibliography_parse(a, xml, node)
-            elsif node.attr("style") == "bibliography"
+            elsif @biblio || node.attr("style") == "bibliography"
               bibliography_parse(a, xml, node)
             elsif node.attr("style") == "abstract"
               abstract_parse(a, xml, node)
@@ -118,7 +117,9 @@ module Asciidoctor
       def preamble(node)
         noko do |xml|
           xml.foreword **attr_code(section_attributes(node)) do |xml_abstract|
-            xml_abstract.title { |t| t << (node.blocks[0].title || @i18n.foreword) }
+            xml_abstract.title do |t|
+              t << (node.blocks[0].title || @i18n.foreword)
+            end
             content = node.content
             xml_abstract << content
           end
@@ -143,7 +144,7 @@ module Asciidoctor
       end
 
       def clause_parse(attrs, xml, node)
-        attrs["inline-header".to_sym] = node.option? "inline-header"
+        attrs[:"inline-header"] = node.option? "inline-header"
         attrs[:bibitem] = true if node.option? "bibitem"
         attrs[:level] = node.attr("level")
         set_obligation(attrs, node)
@@ -154,7 +155,7 @@ module Asciidoctor
       end
 
       def annex_parse(attrs, xml, node)
-        attrs["inline-header".to_sym] = node.option? "inline-header"
+        attrs[:"inline-header"] = node.option? "inline-header"
         set_obligation(attrs, node)
         xml.annex **attr_code(attrs) do |xml_section|
           xml_section.title { |name| name << node.title }
@@ -180,7 +181,7 @@ module Asciidoctor
 
       def acknowledgements_parse(attrs, xml, node)
         xml.acknowledgements **attr_code(attrs) do |xml_section|
-          xml_section.title { |t| t << node.title || @i18n.acknowledgements }
+          xml_section.title { |t| (t << node.title) || @i18n.acknowledgements }
           content = node.content
           xml_section << content
         end

data/lib/asciidoctor/standoc/term_lookup_cleanup.rb

@@ -1,4 +1,6 @@
 # frozen_string_literal: true.
+require "asciidoctor/standoc/utils"
+
 
 module Asciidoctor
   module Standoc
@@ -13,7 +15,7 @@ module Asciidoctor
       def initialize(xmldoc, log)
         @xmldoc = xmldoc
         @log = log
-        @termlookup = { term: {}, symbol: {} }
+        @termlookup = { term: {}, symbol: {}, secondary2primary: {} }
         @idhash = {}
       end
 
@@ -22,6 +24,7 @@ module Asciidoctor
         @termlookup = replace_automatic_generated_ids_terms
         set_termxref_tags_target
         concept_cleanup
+        related_cleanup
       end
 
       private
@@ -29,6 +32,19 @@ module Asciidoctor
       def concept_cleanup
         xmldoc.xpath("//concept").each do |n|
           n.delete("type")
+          refterm = n.at("./refterm") or next
+          p = @termlookup[:secondary2primary][refterm.text] and
+            refterm.children = p
+        end
+      end
+
+      def related_cleanup
+        xmldoc.xpath("//related").each do |n|
+          refterm = n.at("./refterm") or next
+          p = @termlookup[:secondary2primary][refterm.text] and
+            refterm.children = p
+          refterm.replace("<preferred><expression><name>#{refterm.children.to_xml}"\
+                          "</name></expression></preferred>")
         end
       end
 
@@ -47,8 +63,7 @@ module Asciidoctor
             remove_missing_ref(node, target)
             next
           end
-          x = node.at("../xrefrender")
-          modify_ref_node(x, target)
+          x = node.at("../xrefrender") and modify_ref_node(x, target)
           node.name = "refterm"
         end
       end
@@ -66,12 +81,12 @@ module Asciidoctor
                 %(Error: Term reference in `term[#{target}]` missing: \
                 "#{target}" is not defined in document))
         node.name = "strong"
-        node.at("../xrefrender").remove
+        node&.at("../xrefrender")&.remove
         display = node&.at("../renderterm")&.remove&.children
         display = [] if display.nil? || display&.to_xml == node.text
         d = display.empty? ? "" : ", display <tt>#{display.to_xml}</tt>"
         node.children = "term <tt>#{node.text}</tt>#{d} "\
-          "not resolved via ID <tt>#{target}</tt>"
+                        "not resolved via ID <tt>#{target}</tt>"
       end
 
       def remove_missing_ref_symbol(node, target)
@@ -79,12 +94,12 @@ module Asciidoctor
                 %(Error: Symbol reference in `symbol[#{target}]` missing: \
                 "#{target}" is not defined in document))
         node.name = "strong"
-        node.at("../xrefrender").remove
+        node&.at("../xrefrender")&.remove
         display = node&.at("../renderterm")&.remove&.children
         display = [] if display.nil? || display&.to_xml == node.text
         d = display.empty? ? "" : ", display <tt>#{display.to_xml}</tt>"
         node.children = "symbol <tt>#{node.text}</tt>#{d} "\
-          "not resolved via ID <tt>#{target}</tt>"
+                        "not resolved via ID <tt>#{target}</tt>"
       end
 
       def modify_ref_node(node, target)
@@ -92,24 +107,40 @@ module Asciidoctor
         s = termlookup[:symbol][target]
         t = termlookup[:term][target]
         type = node.parent["type"]
-        if type == "term" || !type && t
+        if type == "term" || ((!type || node.parent.name == "related") && t)
           node["target"] = t
-        elsif type == "symbol" || !type && s
+        elsif type == "symbol" ||
+          ((!type || node.parent.name == "related") && s)
           node["target"] = s
         end
       end
 
       def replace_automatic_generated_ids_terms
         r = xmldoc.xpath("//term").each.with_object({}) do |n, res|
-          normalize_id_and_memorize(n, res, "./preferred", "term")
+          normalize_id_and_memorize(n, res, "./preferred//name",
+                                    "term")
         end
         s = xmldoc.xpath("//definitions//dt").each.with_object({}) do |n, res|
           normalize_id_and_memorize(n, res, ".", "symbol")
         end
-        { term: r, symbol: s }
+        { term: r, symbol: s, secondary2primary: pref_secondary2primary }
+      end
+
+      def pref_secondary2primary
+        xmldoc.xpath("//term").each.with_object({}) do |n, res|
+          n.xpath("./preferred//name").each_with_index do |p, i|
+            i.zero? and term = p.text
+            i.positive? and res[p.text] = term
+          end
+        end
       end
 
       def normalize_id_and_memorize(node, res_table, text_selector, prefix)
+        normalize_id_and_memorize_init(node, res_table, text_selector, prefix)
+        memorize_other_pref_terms(node, res_table, text_selector)
+      end
+
+      def normalize_id_and_memorize_init(node, res_table, text_selector, prefix)
         term_text = normalize_ref_id(node.at(text_selector).text)
         unless AUTOMATIC_GENERATED_ID_REGEXP.match(node["id"]).nil? &&
             !node["id"].nil?
@@ -120,6 +151,14 @@ module Asciidoctor
         res_table[term_text] = node["id"]
       end
 
+      def memorize_other_pref_terms(node, res_table, text_selector)
+        node.xpath(text_selector).each_with_index do |p, i|
+          next unless i.positive?
+
+          res_table[normalize_ref_id(p.text)] = node["id"]
+        end
+      end
+
       def normalize_ref_id(text)
         Metanorma::Utils::to_ncname(text.downcase.gsub(/[[:space:]]/, "-"))
       end

data/lib/asciidoctor/standoc/terms.rb

@@ -69,7 +69,7 @@ module Asciidoctor
 
       def term_def_subclause_parse1(attrs, xml, node)
         xml.term **attr_code(attrs) do |xml_section|
-          xml_section.preferred { |name| name << node.title }
+          term_designation(xml_section, node, "preferred", node.title)
           xml_section << node.content
         end
       end
@@ -84,6 +84,14 @@ module Asciidoctor
         end
       end
 
+      def term_designation(xml, _node, tag, text)
+        xml.send tag do |p|
+          p.expression do |e|
+            e.name { |name| name << text }
+          end
+        end
+      end
+
       def term_source_attrs(_node, seen_xref)
         { case: seen_xref.children[0]["case"],
           droploc: seen_xref.children[0]["droploc"],
@@ -124,7 +132,9 @@ module Asciidoctor
       def termsource(node)
         matched = extract_termsource_refs(node.content, node) || return
         noko do |xml|
-          attrs = { status: matched[:text] ? "modified" : "identical" }
+          status = node.attr("status") ||
+            (matched[:text] ? "modified" : "identical")
+          attrs = { status: status, type: node.attr("type") || "authoritative" }
           xml.termsource **attrs do |xml_t|
             seen_xref = Nokogiri::XML.fragment(matched[:xref])
             add_term_source(node, xml_t, seen_xref, matched)