metanorma-standoc 3.0.6 → 3.0.8

data/lib/metanorma/standoc/ref_utility.rb

@@ -32,7 +32,8 @@ module Metanorma
       end
 
       def use_my_anchor(ref, id, opt)
-        ref.parent.elements.last["id"] = id
+        ref.parent.elements.last["anchor"] = id
+        add_id(ref.parent.elements.last)
         a = opt[:hidden] and ref.parent.elements.last["hidden"] = a
         a = opt[:dropid] and
           ref.parent.elements.last["suppress_identifier"] = a
@@ -195,8 +196,8 @@ module Metanorma
 
       def ref_attributes(match)
         code = analyse_ref_code(match[:code])
-
-        { id: match[:anchor], type: "standard",
+        { anchor: match[:anchor], id: "_#{UUIDTools::UUID.random_create}",
+          type: "standard",
           suppress_identifier: code[:dropid] || nil }
       end
 

data/lib/metanorma/standoc/section.rb

@@ -1,6 +1,7 @@
 require "uri" if /^2\./.match?(RUBY_VERSION)
 require_relative "ref_sect"
 require_relative "terms"
+require_relative "sectiontype"
 
 module Metanorma
   module Standoc
@@ -9,85 +10,13 @@ module Metanorma
       @term_def = false
       @norm_ref = false
 
-      def sectiontype1(node)
-        node.attr("style") == "abstract" and return "abstract"
-        node.attr("heading")&.downcase ||
-          node.title
-            .gsub(%r{<index>.*?</index>}m, "")
-            .gsub(%r{<fn[^<>]*>.*?</fn>}m, "")
-            .gsub(/<[^<>]+>/, "")
-            .strip.downcase.sub(/\.$/, "")
-      end
-
-      def sectiontype(node, level = true)
-        ret = sectiontype1(node)
-        ret1 = preface_main_filter(sectiontype_streamline(ret), node)
-        ret1 == "symbols and abbreviated terms" and return ret1
-        !level || node.level == 1 || node.attr("heading") or return nil
-        !node.attr("heading") && @seen_headers.include?(ret) and return nil
-        @seen_headers << ret unless ret1.nil?
-        @seen_headers_canonical << ret1 unless ret1.nil?
-        ret1
-      end
-
-      def sectiontype_streamline(ret)
-        case ret
-        when "terms and definitions",
-          "terms, definitions, symbols and abbreviated terms",
-          "terms, definitions, symbols and abbreviations",
-          "terms, definitions and symbols",
-          "terms, definitions and abbreviations",
-          "terms, definitions and abbreviated terms"
-          "terms and definitions"
-        when "symbols and abbreviated terms",
-          "symbols", "abbreviated terms", "abbreviations",
-          "symbols and abbreviations"
-          "symbols and abbreviated terms"
-        when "acknowledgements", "acknowledgments"
-          "acknowledgements"
-        else
-          ret
-        end
-      end
-
-      PREFACE_CLAUSE_NAMES =
-        %w(abstract foreword introduction metanorma-extension termdocsource
-           misc-container metanorma-extension acknowledgements).freeze
-
-      MAIN_CLAUSE_NAMES =
-        ["normative references", "terms and definitions", "scope",
-         "symbols and abbreviated terms", "clause", "bibliography"].freeze
-
-      def role_style(node, value)
-        node.role == value || node.attr("style") == value
-      end
-
-      def start_main_section(ret, node)
-        role_style(node, "preface") and return
-        @preface = false if self.class::MAIN_CLAUSE_NAMES.include?(ret)
-        @preface = false if self.class::PREFACE_CLAUSE_NAMES
-          .intersection(@seen_headers_canonical + [ret]).empty?
-      end
-
-      def preface_main_filter(ret, node)
-        start_main_section(ret, node)
-        if @preface
-          self.class::MAIN_CLAUSE_NAMES.include?(ret) and return nil
-        else
-          self.class::PREFACE_CLAUSE_NAMES.include?(ret) and return nil
-        end
-
-        ret
-      end
-
       def section_attributes(node)
-        ret =
-          { id: Metanorma::Utils::anchor_or_uuid(node),
-            unnumbered: node.option?("unnumbered") ? "true" : nil,
-            annex: role_style(node, "appendix") && node.level == 1 ? true : nil,
+        ret = id_unnum_attrs(node).merge(
+          { annex: role_style(node, "appendix") && node.level == 1 ? true : nil,
             colophon: role_style(node, "colophon") ? true : nil,
-            preface: role_style(node, "preface") ? true : nil }
-        %w(language script number branch-number type tag keeptitle
+            preface: role_style(node, "preface") ? true : nil },
+        )
+        %w(language script branch-number type tag keeptitle
            multilingual-rendering).each do |k|
           a = node.attr(k) and ret[k.to_sym] = a
         end
@@ -120,6 +49,8 @@ module Metanorma
             symbols_parse(symbols_attrs(node, a), xml, node)
           when "acknowledgements"
             acknowledgements_parse(a, xml, node)
+          when "executivesummary"
+            executivesummary_parse(a, xml, node)
           when "bibliography"
             bibliography_parse(a, xml, node)
           else
@@ -188,47 +119,74 @@ module Metanorma
         clause_parse(attrs.merge(type: "scope"), xml, node)
       end
 
-      def clause_parse(attrs, xml, node)
+      def clause_attrs_preprocess(attrs, node)
         attrs[:"inline-header"] = node.option? "inline-header"
         attrs[:bibitem] = true if node.option? "bibitem"
         attrs[:level] = node.attr("level")
         set_obligation(attrs, node)
+      end
+
+      def clause_parse(attrs, xml, node)
+        clause_attrs_preprocess(attrs, node)
+        node.option?("appendix") && support_appendix?(node) and
+          return appendix_parse(attrs, xml, node)
         xml.send :clause, **attr_code(attrs) do |xml_section|
           xml_section.title { |n| n << node.title } unless node.title.nil?
           xml_section << node.content
         end
       end
 
-      def annex_parse(attrs, xml, node)
+      def annex_attrs_preprocess(attrs, node)
         attrs[:"inline-header"] = node.option? "inline-header"
         set_obligation(attrs, node)
+      end
+
+      def annex_parse(attrs, xml, node)
+        annex_attrs_preprocess(attrs, node)
         xml.annex **attr_code(attrs) do |xml_section|
           xml_section.title { |name| name << node.title }
           xml_section << node.content
         end
       end
 
+      def support_appendix?(_node)
+        false
+      end
+
+      def appendix_parse(attrs, xml, node)
+        attrs[:"inline-header"] = node.option? "inline-header"
+        set_obligation(attrs, node)
+        xml.appendix **attr_code(attrs) do |xml_section|
+          xml_section.title { |name| name << node.title }
+          xml_section << node.content
+        end
+      end
+
       def introduction_parse(attrs, xml, node)
         xml.introduction **attr_code(attrs) do |xml_section|
           xml_section.title { |t| t << @i18n.introduction }
-          content = node.content
-          xml_section << content
+          xml_section << node.content
         end
       end
 
       def foreword_parse(attrs, xml, node)
         xml.foreword **attr_code(attrs) do |xml_section|
           xml_section.title { |t| t << node.title }
-          content = node.content
-          xml_section << content
+          xml_section << node.content
         end
       end
 
       def acknowledgements_parse(attrs, xml, node)
         xml.acknowledgements **attr_code(attrs) do |xml_section|
           xml_section.title { |t| (t << node.title) || @i18n.acknowledgements }
-          content = node.content
-          xml_section << content
+          xml_section << node.content
+        end
+      end
+
+      def executivesummary_parse(attrs, xml, node)
+        xml.executivesummary **attr_code(attrs) do |xml_section|
+          xml_section.title { |t| (t << node.title) || @i18n.executivesummary }
+          xml_section << node.content
         end
       end
 

data/lib/metanorma/standoc/sectiontype.rb

@@ -0,0 +1,76 @@
+module Metanorma
+  module Standoc
+    module Section
+      def sectiontype1(node)
+        node.attr("style") == "abstract" and return "abstract"
+        node.attr("heading")&.downcase ||
+          node.title
+            .gsub(%r{<index>.*?</index>}m, "")
+            .gsub(%r{<fn[^<>]*>.*?</fn>}m, "")
+            .gsub(/<[^<>]+>/, "")
+            .strip.downcase.sub(/\.$/, "")
+      end
+
+      def sectiontype(node, level = true)
+        ret = sectiontype1(node)
+        ret1 = preface_main_filter(sectiontype_streamline(ret), node)
+        ret1 == "symbols and abbreviated terms" and return ret1
+        !level || node.level == 1 || node.attr("heading") or return nil
+        !node.attr("heading") && @seen_headers.include?(ret) and return nil
+        @seen_headers << ret unless ret1.nil?
+        @seen_headers_canonical << ret1 unless ret1.nil?
+        ret1
+      end
+
+      def sectiontype_streamline(ret)
+        case ret
+        when "terms and definitions",
+          "terms, definitions, symbols and abbreviated terms",
+          "terms, definitions, symbols and abbreviations",
+          "terms, definitions and symbols",
+          "terms, definitions and abbreviations",
+          "terms, definitions and abbreviated terms"
+          "terms and definitions"
+        when "symbols and abbreviated terms",
+          "symbols", "abbreviated terms", "abbreviations",
+          "symbols and abbreviations"
+          "symbols and abbreviated terms"
+        when "acknowledgements", "acknowledgments"
+          "acknowledgements"
+        when "executive summary", "executive-summary", "executive_summary"
+          "executivesummary"
+        else
+          ret
+        end
+      end
+
+      PREFACE_CLAUSE_NAMES =
+        %w(abstract foreword introduction metanorma-extension termdocsource
+           misc-container metanorma-extension acknowledgements executivesummary)
+          .freeze
+
+      MAIN_CLAUSE_NAMES =
+        ["normative references", "terms and definitions", "scope",
+         "symbols and abbreviated terms", "clause", "bibliography"].freeze
+
+      def role_style(node, value)
+        node.role == value || node.attr("style") == value
+      end
+
+      def start_main_section(ret, node)
+        role_style(node, "preface") and return
+        @preface = false if self.class::MAIN_CLAUSE_NAMES.include?(ret)
+        @preface = false if self.class::PREFACE_CLAUSE_NAMES
+          .intersection(@seen_headers_canonical + [ret]).empty?
+      end
+
+      def preface_main_filter(ret, node)
+        start_main_section(ret, node)
+        @preface && self.class::MAIN_CLAUSE_NAMES.include?(ret) and return nil
+        !@preface && self.class::PREFACE_CLAUSE_NAMES.include?(ret) and
+          return nil
+        ret
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/table.rb

@@ -3,11 +3,8 @@ module Metanorma
     module Table
       def table_attrs(node)
         keep_attrs(node)
-          .merge(id: Metanorma::Utils::anchor_or_uuid(node),
-                 headerrows: node.attr("headerrows"),
-                 unnumbered: node.option?("unnumbered") ? "true" : nil,
-                 number: node.attr("number"),
-                 subsequence: node.attr("subsequence"),
+          .merge(id_unnum_attrs(node))
+          .merge(headerrows: node.attr("headerrows"),
                  alt: node.attr("alt"),
                  summary: node.attr("summary"),
                  width: node.attr("width"))
@@ -28,11 +25,9 @@ module Metanorma
       private
 
       def colgroup(node, xml_table)
-        return if node.option? "autowidth"
-
-        cols = node&.attr("cols")&.split(/,/) or return
-        return unless (cols.size > 1) && cols.all? { |c| /\d/.match(c) }
-
+        node.option? "autowidth" and return
+        cols = node.attr("cols")&.split(",") or return
+        (cols.size > 1) && cols.all? { |c| /\d/.match(c) } or return
         xml_table.colgroup do |cg|
           node.columns.each do |col|
             cg.col width: "#{col.attr 'colpcwidth'}%"
@@ -57,9 +52,10 @@ module Metanorma
       end
 
       def table_cell(node, xml_tr, tblsec)
-        cell_attributes =
-          { id: node.id, colspan: node.colspan, valign: node.attr("valign"),
-            rowspan: node.rowspan, align: node.attr("halign") }
+        cell_attributes = id_attr(node).merge(
+          { colspan: node.colspan, valign: node.attr("valign"),
+            rowspan: node.rowspan, align: node.attr("halign") },
+        )
         cell_tag = "td"
         cell_tag = "th" if tblsec == :head || node.style == :header
         xml_tr.send cell_tag, **attr_code(cell_attributes) do |thd|

data/lib/metanorma/standoc/term_lookup_cleanup.rb

@@ -16,11 +16,13 @@ module Metanorma
         @unique_designs = {}
         @c = HTMLEntities.new
         @terms_tags = xmldoc.xpath("//terms").each_with_object({}) do |t, m|
-          m[t["id"]] = true
+          #m[t["id"]] = true
+          m[t["anchor"]] = true
         end
       end
 
       def call
+        #require "debug"; binding.b
         @idhash = populate_idhash
         @unique_designs = unique_designators
         @lookup = replace_automatic_generated_ids_terms
@@ -29,6 +31,7 @@ module Metanorma
         related_cleanup
         remove_missing_refs
         concept_cleanup2
+        anchor_to_id
       end
 
       private
@@ -36,7 +39,7 @@ module Metanorma
       def unique_designators
         ret = xmldoc
           .xpath("//preferred/expression/name | //admitted/expression/name | " \
-                 "//deprecated/expression/name").each_with_object({}) do |n, m|
+                 "//deprecates/expression/name").each_with_object({}) do |n, m|
           m[n.text] ||= 0
           m[n.text] += 1
         end
@@ -69,9 +72,12 @@ module Metanorma
       end
 
       def populate_idhash
-        xmldoc.xpath("//*[@id]").each_with_object({}) do |n, mem|
-          /^(term|symbol)-/.match?(n["id"]) or next
-          mem[n["id"]] = true
+        #xmldoc.xpath("//*[@id]").each_with_object({}) do |n, mem|
+        xmldoc.xpath("//*[@anchor]").each_with_object({}) do |n, mem|
+          #/^(term|symbol)-/.match?(n["id"]) or next
+          /^(term|symbol)-/.match?(n["anchor"]) or next
+          #mem[n["id"]] = true
+          mem[n["anchor"]] = true
         end
       end
 
@@ -207,18 +213,22 @@ module Metanorma
 
       def norm_id_memorize_init(node, res_table, selector, prefix, use_domain)
         term_text = norm_ref_id(node, selector, use_domain) or return
-        unless AUTO_GEN_ID_REGEXP.match(node["id"]).nil? && !node["id"].nil?
+        #unless AUTO_GEN_ID_REGEXP.match(node["id"]).nil? && !node["id"].nil?
+        unless AUTO_GEN_ID_REGEXP.match(node["anchor"]).nil? && !node["anchor"].nil?
           id = unique_text_id(term_text, prefix)
-          node["id"] = id
+          #node["id"] = id
+          node["anchor"] = id
           @idhash[id] = true
         end
-        res_table[term_text] = node["id"]
+        #res_table[term_text] = node["id"]
+        res_table[term_text] = node["anchor"]
       end
 
       def memorize_other_pref_terms(node, res_table, text_selector, use_domain)
         node.xpath(text_selector).each_with_index do |p, i|
           i.positive? or next
-          res_table[norm_ref_id1(p, use_domain ? node : nil)] = node["id"]
+          #res_table[norm_ref_id1(p, use_domain ? node : nil)] = node["id"]
+          res_table[norm_ref_id1(p, use_domain ? node : nil)] = node["anchor"]
         end
       end
 
@@ -255,6 +265,13 @@ module Metanorma
         end
       end
 
+      def anchor_to_id
+        xmldoc.xpath("//*[@anchor]").each do |n|
+          /^(term|symbol)-/.match?(n["anchor"]) or next
+          n["id"] or add_id(n)
+        end
+      end
+
       include ::Metanorma::Standoc::Utils
     end
   end

data/lib/metanorma/standoc/terms.rb

@@ -157,7 +157,7 @@ module Metanorma
       def termsource(node)
         matched = extract_termsource_refs(node.content, node) or return
         noko do |xml|
-          xml.termsource **termsource_attrs(node, matched) do |xml_t|
+          xml.source **termsource_attrs(node, matched) do |xml_t|
             seen_xref = Nokogiri::XML.fragment(matched[:xref])
             add_term_source(node, xml_t, seen_xref, matched)
           end

data/lib/metanorma/standoc/utils.rb

@@ -35,6 +35,10 @@ module Metanorma
         Metanorma::Utils::attr_code(attributes)
       end
 
+      def add_id(node)
+        node["id"] = "_#{UUIDTools::UUID.random_create}"
+      end
+
       def csv_split(text, delim = ";")
         Metanorma::Utils::csv_split(@c.decode(text), delim)
           .map { |x| @c.encode(x, :basic, :hexadecimal) }
@@ -119,7 +123,7 @@ module Metanorma
       end
 
       SECTION_CONTAINERS =
-        %w(foreword introduction acknowledgements abstract
+        %w(foreword introduction acknowledgements executivesummary abstract
            clause references terms definitions annex appendix indexsect
            executivesummary).freeze
 

data/lib/metanorma/standoc/validate.rb

@@ -12,7 +12,7 @@ module Metanorma
     module Validate
       def content_validate(doc)
         @doctype = doc.at("//bibdata/ext/doctype")&.text
-        repeat_id_validate(doc.root) # feeds xref_validate
+        repeat_id_validate(doc.root) # feeds xref_validate, termsect_validate
         xref_validate(doc) # feeds nested_asset_validate
         nested_asset_validate(doc)
         section_validate(doc)
@@ -92,7 +92,7 @@ module Metanorma
       end
 
       def nested_asset_xref_report(outer, inner, _doc)
-        i = @doc_xrefs[inner["id"]] or return
+        i = @doc_xrefs[inner["anchor"]] or return
         err2 = "There is a crossreference to an instance of #{inner.name} " \
                "nested within #{outer.name}: #{i.to_xml}"
         @log.add("Style", i, err2)
@@ -158,32 +158,98 @@ module Metanorma
         schema_validate(formattedstr_strip(doc.dup), schema_location)
       end
 
+      # Check should never happen with content ids, but will check it anyway
+      # since consequences are so catastrophic
       def repeat_id_validate1(elem)
         if @doc_ids[elem["id"]]
           @log.add("Anchors", elem,
-                   "Anchor #{elem['id']} has already been " \
-                   "used at line #{@doc_ids[elem['id']]}", severity: 0)
+                   "ID #{elem['id']} has already been " \
+                   "used at line #{@doc_ids[elem['id']][:line]}", severity: 0)
+        else
+          @doc_ids[elem["id"]] =
+            { line: elem.line, anchor: elem["anchor"] }.compact
         end
-        @doc_ids[elem["id"]] = elem.line
       end
 
+      def repeat_anchor_validate1(elem)
+        if @doc_anchors[elem["anchor"]]
+          @log.add("Anchors", elem,
+                   "Anchor #{elem['anchor']} has already been used at line " \
+                   "#{@doc_anchors[elem['anchor']][:line]}", severity: 0)
+        else
+          @doc_anchors[elem["anchor"]] = { line: elem.line, id: elem["id"] }
+          @doc_anchor_seq << elem["anchor"]
+        end
+      end
+
+      # Check should never happen with content ids, but will check it anyway
       def repeat_id_validate(doc)
-        @doc_ids = {}
+        repeat_id_validate_prep
         doc.xpath("//*[@id]").each do |x|
+          @doc_id_seq << x["id"]
           repeat_id_validate1(x)
+          x["anchor"] and repeat_anchor_validate1(x)
         end
+        @doc_id_seq_hash = @doc_id_seq.each_with_index
+          .with_object({}) do |(x, i), m|
+          m[x] = i
+        end
+        @doc_anchor_seq_hash = @doc_anchor_seq.each_with_index
+          .with_object({}) do |(x, i), m|
+          m[x] = i
+        end
+      end
+
+      def repeat_id_validate_prep
+        @doc_ids = {} # hash of all ids in document to line number, anchor
+        @doc_anchors = {} # hash of all anchors in document to line number, id
+        @doc_id_seq = [] # ordered list of all ids in document
+        @doc_anchor_seq = [] # ordered list of all anchors in document
       end
 
-      # manually check for xref/@target, xref/@to integrity
+      # Retrieve anchors between two nominated values
+      # (exclusive of start_id AND exclusive of end_id)
+      def get_anchors_between(start_id, end_id)
+        start_index = @doc_anchor_seq_hash[start_id]
+        end_index = @doc_anchor_seq_hash[end_id]
+        start_index.nil? || end_index.nil? and return []
+        start_index >= end_index and return []
+        @doc_anchor_seq[start_index...end_index]
+      end
+
+      # manually check for xref/@target et sim. integrity
       def xref_validate(doc)
-        @doc_xrefs = doc.xpath("//xref/@target | //xref/@to | //index/@to")
-          .each_with_object({}) do |x, m|
-          m[x.text] = x
-          @doc_ids[x.text] and next
-          @log.add("Anchors", x.parent,
-                   "Crossreference target #{x} is undefined", severity: 1)
+        xref_validate_exists(doc)
+        xref_range_record(doc)
+      end
+
+      def xref_validate_exists(doc)
+        @doc_xrefs = {}
+        Metanorma::Utils::anchor_attributes.each do |a|
+          doc.xpath("//#{a[0]}/@#{a[1]}").each do |x|
+            @doc_xrefs[x.text] = x.parent
+            @doc_anchors[x.text] and next
+            @log.add("Anchors", x.parent,
+                     "Crossreference target #{x} is undefined", severity: 1)
+          end
+        end
+      end
+
+      # If there is an xref range, record the IDs between the two targets
+      def xref_range_record(doc)
+        doc.xpath("//xref//location[@connective = 'to']").each do |to|
+          process_range_location(to)
         end
       end
+
+      def process_range_location(to_location)
+        # Get the preceding location element if it exists
+        from = to_location.previous_element
+        from && from.name == "location" or return
+        from["target"] && to_location["target"] or return
+        get_anchors_between(from["target"], to_location["target"])
+          .each { |id| @doc_xrefs[id] = from }
+      end
     end
   end
 end

data/lib/metanorma/standoc/validate_schema.rb

@@ -99,6 +99,8 @@ module Metanorma
         doc.xpath("//m:svg", "m" => SVG_NS).each { |n| n.replace("<svg/>") }
         doc
       end
+
+      include ::Metanorma::Standoc::Utils
     end
   end
 end

data/lib/metanorma/standoc/validate_section.rb

@@ -46,12 +46,11 @@ module Metanorma
 
       def hanging_para_style(root)
         root.xpath("//clause | //annex | //foreword | //introduction | " \
-                   "//acknowledgements").each do |c|
-          next unless c.at("./clause")
-          next if c.elements.reject do |n|
-                    %w(clause title).include? n.name
-                  end.empty?
-
+                   "//acknowledgements | //executivesummary").each do |c|
+          c.at("./clause") or next
+          c.elements.reject do |n|
+            %w(clause title).include? n.name
+          end.empty? and next
           style_warning(c, "Hanging paragraph in clause")
         end
       end

data/lib/metanorma/standoc/validate_term.rb

@@ -16,7 +16,7 @@ module Metanorma
       def iev_validate(xmldoc)
         @iev = init_iev or return
         xmldoc.xpath("//term").each do |t|
-          t.xpath(".//termsource").each do |src|
+          t.xpath("./source | ./preferred/source | ./admitted/source | ./deprecates/source | ./related/source").each do |src|
             (/^IEC[  ]60050-/.match(src.at("./origin/@citeas")&.text) &&
           loc = src.xpath(SOURCELOCALITY)&.text) or next
             iev_validate1(t, loc, xmldoc)
@@ -46,15 +46,16 @@ module Metanorma
 
       def concept_validate_ids(doc)
         @concept_ids ||= doc.xpath("//term | //definitions//dt")
-          .each_with_object({}) { |x, m| m[x["id"]] = true }
+          .each_with_object({}) { |x, m| m[x["anchor"]] = true }
         @concept_terms_tags ||= doc.xpath("//terms")
-          .each_with_object({}) { |t, m| m[t["id"]] = true }
+          .each_with_object({}) { |t, m| m[t["anchor"]] = true }
         nil
       end
 
       def concept_validate_msg(_doc, tag, refterm, xref)
+        t = @doc_ids.dig(xref["target"], :anchor) || xref["target"]
         ret = <<~LOG
-          #{tag.capitalize} #{xref.at("../#{refterm}")&.text} is pointing to #{xref['target']}, which is not a term or symbol
+          #{tag.capitalize} #{xref.at("../#{refterm}")&.text} is pointing to #{t}, which is not a term or symbol
         LOG
         if @concept_terms_tags[xref["target"]]
           ret = ret.strip
@@ -79,7 +80,7 @@ module Metanorma
       def preferred_validate_report(terms)
         terms.each do |k, v|
           v.size > 1 or next
-          loc = v.map { |x| x["id"] }.join(", ")
+          loc = v.map { |x| x["anchor"] }.join(", ")
           err = "Term #{k} occurs twice as preferred designation: #{loc}"
           @log.add("Terms", v.first, err, severity: 1)
         end
@@ -92,7 +93,7 @@ module Metanorma
           c = d.ancestors.detect do |x|
             section_containers.include?(x.name)
           end
-          c["id"] ||= "_#{UUIDTools::UUID.random_create}"
+          c["id"] or add_id(c["id"])
           m[c["id"]] ||= { clause: c, designations: [] }
           m[c["id"]][:designations] << d
         end
@@ -106,7 +107,7 @@ module Metanorma
           end.join(", ")
           err = <<~ERROR
             Clause not recognised as a term clause, but contains designation markup
-             (preferred:[], admitted:[], alt:[], deprecated:[]):<br/>
+             (<code>preferred:[], admitted:[], alt:[], deprecated:[]</code>):<br/>
             #{desgns}</br>
             Ensure the parent clause is recognised as a terms clause by inserting <code>[heading=terms and definitions]</code> above the title,
             in case the heading is not automatically recognised. See also <a href="https://www.metanorma.org/author/topics/sections/concepts/#clause-title">Metanorma documentation</a>.

data/lib/metanorma/standoc/version.rb

@@ -19,6 +19,6 @@ module Metanorma
   end
 
   module Standoc
-    VERSION = "3.0.6".freeze
+    VERSION = "3.0.8".freeze
   end
 end