metanorma-standoc 3.0.8 → 3.0.10

data/lib/metanorma/standoc/macros.rb

@@ -10,7 +10,6 @@ require_relative "macros_embed"
 require_relative "macros_link"
 require_relative "datamodel/attributes_table_preprocessor"
 require_relative "datamodel/diagram_preprocessor"
-require "metanorma-plugin-datastruct"
 require "metanorma-plugin-glossarist"
 require "metanorma-plugin-lutaml"
 
@@ -58,6 +57,7 @@ module Metanorma
           p.process(l)
           p.pass ? l : convert(l, c)
         end
+        log(document, lines)
         ::Asciidoctor::PreprocessorReader.new document, lines
       end
 
@@ -66,6 +66,18 @@ module Metanorma
           /^&[A-Za-z]/.match?(s) ? esc.encode(esc.decode(s), :hexadecimal) : s
         end.join
       end
+
+      # debugging output of results of all preprocessing,
+      # including include files concatenation and Lutaml/Liquid processing
+      def log(doc, text)
+        source = doc.attr("docfile") || "metanorma"
+        dirname  = File.dirname(source)
+        basename = File.basename(source, ".*")
+        fname = File.join(dirname, "#{basename}.asciidoc.log.txt")
+        File.open(fname, "w:UTF-8") do |f|
+          f.write(text.join("\n"))
+        end
+      end
     end
 
     class ColumnBreakBlockMacro < Asciidoctor::Extensions::BlockMacroProcessor
@@ -108,10 +120,14 @@ module Metanorma
 
       def pass_inline_split(text)
         text.split(PASS_INLINE_MACRO_RX).each.map do |x|
-          PASS_INLINE_MACRO_RX.match?(x) ? x : yield(x)
+          PASS_INLINE_MACRO_RX.match?(x) ? pass_convert(x) : yield(x)
         end
       end
 
+      def pass_convert(text)
+        text.sub(/^pass:\[(.+)$/, "pass-format:metanorma[\\1")
+      end
+
       # InlineLinkRx = %r((^|link:|#{CG_BLANK}|&lt;|[>\(\)\[\];"'])(\\?(?:https?|file|ftp|irc)://)(?:([^\s\[\]]+)\[(|#{CC_ALL}*?[^\\])\]|([^\s\[\]<]*([^\s,.?!\[\]<\)]))))m
       #
       InlineLinkRx = %r((^|(?<![-\\])\blink:(?!\+)|\p{Blank}|&lt;|[<>\(\)\[\];"'])((?:https?|file|ftp|irc)://)(?:([^\s\[\]]+)(?:(\[(|.*?[^\\])\])|([^\s\[\]<]*([^\s,.?!\[\]<\)])))))m
@@ -186,5 +202,33 @@ module Metanorma
         end.join
       end
     end
+
+    # convert pass:[] to pass-format:metanorma[]
+    class PassProtectPreprocessor < LinkProtectPreprocessor
+      def process(document, reader)
+        p = Metanorma::Utils::LineStatus.new
+        lines = reader.lines.map do |t|
+          p.process(t)
+          !p.pass && t.include?("pass:") and t = inlinelink(t)
+          t
+        end
+        ::Asciidoctor::PreprocessorReader.new document, lines
+      end
+
+      def pass_inline_split(text)
+        text.split(PASS_INLINE_MACRO_RX).each.map do |x|
+          PASS_INLINE_MACRO_RX.match?(x) ? pass_convert(x) : x
+        end
+      end
+
+      def pass_convert(text)
+        text.sub(/^pass:\[(.+)$/, "pass-format:metanorma[\\1")
+      end
+
+      def inlinelink(text)
+        /^\[.*\]\s*$/.match?(text) and return text
+        pass_inline_split(text).join
+      end
+    end
   end
 end

data/lib/metanorma/standoc/macros_inline.rb

@@ -58,6 +58,30 @@ module Metanorma
       end
     end
 
+    class AnchorInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :anchor
+      parse_content_as :text
+
+      def process(parent, target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        id = "_#{UUIDTools::UUID.random_create}"
+        %{<span id='#{id}' anchor='#{target}'>#{out}</span>}
+      end
+    end
+
+    class SourceIdInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :"source-id"
+      parse_content_as :text
+
+      def process(parent, target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        id = "_#{UUIDTools::UUID.random_create}"
+        %{<span id='#{id}' source='#{target}'>#{out}</span>}
+      end
+    end
+
     class VariantInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
       use_dsl
       named :lang
@@ -111,17 +135,33 @@ module Metanorma
     end
 
     # inject ZWNJ to prevent Asciidoctor from attempting regex substitutions
-    class PassInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+    class PassFormatInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
       use_dsl
       named :"pass-format"
       parse_content_as :text
 
       def process(parent, target, attrs)
-        #require "debug"; binding.b
         format = target || "metanorma"
         out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
-          .gsub(/((?![<>&])[[:punct:]])/, "\\1&#x200c;")
-        %{<passthrough-inline formats="#{format}">#{out}</passthrough-inline>}
+        <<~XML
+          <passthrough-inline formats="#{format}">#{xml_process(out)}</passthrough-inline>
+        XML
+      end
+
+      # Split content into XML tags (including XML-escaped instances),
+      # XML escapes, and text segments
+      # Then only apply ZWNJ to punctuation in text segments
+      def xml_process(out)
+        processed_out = ""
+        segments = out.split(/(<[^>]*>|&lt;[^&]*&gt;|&[^;]*;)/)
+        segments.each_with_index do |segment, index|
+          processed_out += if index.even? # Text segment (not a tag or escape)
+                             segment.gsub(/([[:punct:]])/, "\\1&#x200c;")
+                           else # XML tag or escape
+                             segment
+                           end
+        end
+        processed_out
       end
     end
 

data/lib/metanorma/standoc/macros_link.rb

@@ -76,5 +76,14 @@ module Metanorma
         create_anchor(parent, "hidden=#{t}", type: :xref, target: target)
       end
     end
+
+    class SourceIncludeInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :source_include
+
+      def process(_parent, target, _attrs)
+        "<source-include path='#{target}'/>"
+      end
+    end
   end
 end

data/lib/metanorma/standoc/macros_plantuml.rb

@@ -15,8 +15,13 @@ module Metanorma
         end
       end
 
-      def self.run(umlfile, outfile)
-        system "#{plantuml_bin} #{umlfile.path}" or (warn $? and return false)
+      def self.run(umlfile, outfile, fmt)
+        valid_formats = %w[png svg eps]
+        unless valid_formats.include?(fmt)
+          raise ArgumentError, "Invalid format: #{fmt}. Allowed formats are: #{valid_formats.join(', ')}"
+        end
+        system(plantuml_bin, umlfile.path, "-t#{fmt}") or
+          (warn $? and return false)
         i = 0
         until !Gem.win_platform? || File.exist?(outfile) || i == 15
           sleep(1)
@@ -34,16 +39,24 @@ module Metanorma
       # Windows Ruby 2.4 will crash if a Tempfile is "mv"ed.
       # This is why we need to copy and then unlink.
       def self.generate_file(parent, reader)
-        ldir = localdir(parent)
-        imagesdir = parent.document.attr("imagesdir")
-        umlfile, outfile = save_plantuml parent, reader, ldir
-        run(umlfile, outfile) or
+        ldir, imagesdir, fmt = generate_file_prep(parent)
+        umlfile, outfile = save_plantuml parent, reader, ldir, fmt
+        run(umlfile, outfile, fmt) or
           raise "No image output from PlantUML (#{umlfile}, #{outfile})!"
         umlfile.unlink
-        path = path_prep(ldir, imagesdir)
+        absolute_path, relative_path = path_prep(ldir, imagesdir)
         filename = File.basename(outfile.to_s)
-        FileUtils.cp(outfile, path) and outfile.unlink
-        imagesdir ? filename : File.join(path, filename)
+        FileUtils.cp(outfile, absolute_path) and outfile.unlink
+        #imagesdir ? filename : File.join(path, filename)
+        File.join(relative_path, filename)
+      end
+
+      def self.generate_file_prep(parent)
+        ldir = localdir(parent)
+        imagesdir = parent.document.attr("imagesdir")
+        fmt = parent.document.attr("plantuml-image-format")&.strip&.downcase ||
+          "png"
+        [ldir, imagesdir, fmt]
       end
 
       def self.localdir(parent)
@@ -54,21 +67,22 @@ module Metanorma
       end
 
       def self.path_prep(localdir, imagesdir)
-        path = Pathname.new(localdir) + (imagesdir || "plantuml")
+        #path = Pathname.new(localdir) + (imagesdir || "plantuml")
+        path = Pathname.new(File.join(localdir, "_plantuml_images"))
+        sourcepath = imagesdir ? File.join(localdir, imagesdir) : localdir
         path.mkpath
         File.writable?(path) or
           raise "Destination path #{path} not writable for PlantUML!"
-        # File.exist?(path) or raise "Destination path #{path} already exists for PlantUML!"
-        path
+        [path, Pathname.new(path).relative_path_from(Pathname.new(sourcepath)).to_s]
       end
 
-      def self.save_plantuml(_parent, reader, _localdir)
+      def self.save_plantuml(_parent, reader, _localdir, fmt)
         src = prep_source(reader)
         /^@startuml (?<fn>[^\n]+)\n/ =~ src
         Tempfile.open(["plantuml", ".pml"], encoding: "utf-8") do |f|
           f.write(src)
           [f, File.join(File.dirname(f.path),
-                        "#{fn || File.basename(f.path, '.pml')}.png")]
+                        "#{fn || File.basename(f.path, '.pml')}.#{fmt}")]
         end
       end
 

data/lib/metanorma/standoc/ref_sect.rb

@@ -14,7 +14,7 @@ module Metanorma
         @biblio = true
         attrs = attrs.merge(normative: node.attr("normative") || false)
         xml.references **attr_code(attrs) do |xml_section|
-          xml_section.title { |t| t << node.title }
+          section_title(xml_section, node.title)
           xml_section << node.content
         end
         @biblio = false
@@ -36,7 +36,7 @@ module Metanorma
         @norm_ref = true
         attrs = attrs.merge(normative: node.attr("normative") || true)
         xml.references **attr_code(attrs) do |xml_section|
-          xml_section.title { |t| t << node.title }
+          section_title(xml_section, node.title)
           xml_section << node.content
         end
         @norm_ref = false

data/lib/metanorma/standoc/render.rb

@@ -2,8 +2,7 @@ module Metanorma
   module Standoc
     module Base
       def html_extract_attributes(node)
-        i18nyaml = node.attr("i18nyaml")
-        i18nyaml &&= File.join(@localdir, i18nyaml)
+        i18nyaml = i18nyaml_path(node)
         {
           script: node.attr("script"),
           bodyfont: node.attr("body-font"),
@@ -11,10 +10,10 @@ module Metanorma
           monospacefont: node.attr("monospace-font"),
           i18nyaml: i18nyaml,
           scope: node.attr("scope"),
-          htmlstylesheet: node.attr("htmlstylesheet"),
-          htmlstylesheet_override: node.attr("htmlstylesheet-override"),
-          htmlcoverpage: node.attr("htmlcoverpage"),
-          htmlintropage: node.attr("htmlintropage"),
+          htmlstylesheet: node.attr("htmlstylesheet") || node.attr("html-stylesheet"),
+          htmlstylesheet_override: node.attr("htmlstylesheet-override") || node.attr("html-stylesheet-override"),
+          htmlcoverpage: node.attr("htmlcoverpage") || node.attr("htmlcoverpage"),
+          htmlintropage: node.attr("htmlintropage") || node.attr("html-intropage"),
           scripts: node.attr("scripts"),
           scripts_override: node.attr("scripts-override"),
           scripts_pdf: node.attr("scripts-pdf"),
@@ -50,8 +49,7 @@ module Metanorma
       end
 
       def doc_extract_attributes(node)
-        i18nyaml = node.attr("i18nyaml")
-        i18nyaml &&= File.join(@localdir, i18nyaml)
+        i18nyaml = i18nyaml_path(node)
         attrs = {
           script: node.attr("script"),
           bodyfont: node.attr("body-font"),
@@ -59,9 +57,9 @@ module Metanorma
           monospacefont: node.attr("monospace-font"),
           i18nyaml: i18nyaml,
           scope: node.attr("scope"),
-          wordstylesheet: node.attr("wordstylesheet"),
-          wordstylesheet_override: node.attr("wordstylesheet-override"),
-          standardstylesheet: node.attr("standardstylesheet"),
+          wordstylesheet: node.attr("wordstylesheet") || node.attr("word-stylesheet"),
+          wordstylesheet_override: node.attr("wordstylesheet-override") || node.attr("word-stylesheet-override"),
+          standardstylesheet: node.attr("standardstylesheet") || node.attr("standard-stylesheet"),
           header: node.attr("header"),
           wordcoverpage: node.attr("wordcoverpage"),
           wordintropage: node.attr("wordintropage"),
@@ -96,13 +94,24 @@ module Metanorma
                          pdf-allow-assemble-document pdf-allow-edit-annotations
                          pdf-allow-print pdf-allow-print-hq
                          pdf-allow-access-content pdf-encrypt-metadata fonts
+                         pdf-stylesheet pdf-stylesheet-override
                          font-license-agreement).each_with_object({}) do |x, m|
-          m[x.delete("-").to_i] = node.attr(x)
+          m[x.delete("-").sub(/override$/, "_override").to_sym] =
+            node.attr(x) || node.attr(x.sub("pdf-", "pdf"))
         end
-
+        absolute_path_pdf_attributes(pdf_options)
         pdf_options.merge(fonts_manifest_option(node) || {})
       end
 
+      def absolute_path_pdf_attributes(pdf_options)
+        %i(pdfstylesheet pdfstylesheet_override).each do |x|
+          pdf_options[x] or next
+          (Pathname.new pdf_options[x]).absolute? or
+            pdf_options[x] =
+              File.join(File.expand_path(@localdir), pdf_options[x])
+        end
+      end
+
       def doc_converter(node)
         IsoDoc::WordConvert.new(doc_extract_attributes(node))
       end

data/lib/metanorma/standoc/section.rb

@@ -35,8 +35,8 @@ module Metanorma
         a = section_attributes(node)
         noko do |xml|
           case sectiontype(node)
-          when "misc-container", "metanorma-extension"
-            misccontainer_parse(a, xml, node)
+          when "metanorma-extension"
+            metanorma_extension_parse(a, xml, node)
           when "introduction" then introduction_parse(a, xml, node)
           when "foreword" then foreword_parse(a, xml, node)
           when "scope" then scope_parse(a, xml, node)
@@ -85,26 +85,31 @@ module Metanorma
           end
       end
 
+      def section_title(xml, title)
+        title.nil? and return
+        xml.title **attr_code(id_attr(nil)) do |t|
+          t << title
+        end
+      end
+
       def preamble(node)
         noko do |xml|
           xml.foreword **attr_code(section_attributes(node)) do |xml_abstract|
-            xml_abstract.title do |t|
-              t << (node.blocks[0].title || @i18n.foreword)
-            end
+            section_title(xml_abstract, node.blocks[0].title || @i18n.foreword)
             xml_abstract << node.content
           end
         end
       end
 
-      def misccontainer_parse(_attrs, xml, node)
-        xml.send :"misc-container-clause" do |xml_section|
+      def metanorma_extension_parse(_attrs, xml, node)
+        xml.send :"metanorma-extension-clause" do |xml_section|
           xml_section << node.content
         end
       end
 
       def indexsect_parse(attrs, xml, node)
         xml.indexsect **attr_code(attrs) do |xml_section|
-          xml_section.title { |name| name << node.title }
+          section_title(xml_section, node.title)
           xml_section << node.content
         end
       end
@@ -131,7 +136,7 @@ module Metanorma
         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?
+          section_title(xml_section, node.title)
           xml_section << node.content
         end
       end
@@ -144,7 +149,7 @@ module Metanorma
       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 }
+          section_title(xml_section, node.title)
           xml_section << node.content
         end
       end
@@ -157,35 +162,35 @@ module Metanorma
         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 }
+          section_title(xml_section, 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 }
+          section_title(xml_section, @i18n.introduction)
           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 }
+          section_title(xml_section, node.title)
           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 }
+          section_title(xml_section, node.title || @i18n.acknowledgements)
           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 }
+          section_title(xml_section, node.title || @i18n.executivesummary)
           xml_section << node.content
         end
       end

data/lib/metanorma/standoc/sectiontype.rb

@@ -14,7 +14,9 @@ module Metanorma
       def sectiontype(node, level = true)
         ret = sectiontype1(node)
         ret1 = preface_main_filter(sectiontype_streamline(ret), node)
-        ret1 == "symbols and abbreviated terms" and return ret1
+        # permit multiple instances
+        ["symbols and abbreviated terms",
+         "metanorma-extension"].include?(ret1) 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?
@@ -22,31 +24,37 @@ module Metanorma
         ret1
       end
 
+      SECTIONTYPE_STREAMLINE =
+        { "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"],
+          "symbols and abbreviated terms":
+        ["symbols and abbreviated terms",
+         "symbols", "abbreviated terms", "abbreviations",
+         "symbols and abbreviations",
+         "symbols and abbreviated terms"],
+          "acknowledgements":
+        ["acknowledgements", "acknowledgments"],
+          "executivesummary":
+          ["executive summary", "executive-summary",
+           "executive_summary"],
+          "metanorma-extension":
+       ["misc-container", "metanorma-extension"] }.freeze
+
       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
+        SECTIONTYPE_STREAMLINE.each do |k, v|
+          v.include?(ret) and return k.to_s
         end
+        ret
       end
 
       PREFACE_CLAUSE_NAMES =
         %w(abstract foreword introduction metanorma-extension termdocsource
-           misc-container metanorma-extension acknowledgements executivesummary)
+           metanorma-extension acknowledgements executivesummary)
           .freeze
 
       MAIN_CLAUSE_NAMES =

data/lib/metanorma/standoc/table.rb

@@ -36,11 +36,7 @@ module Metanorma
       end
 
       def table_name(node, xml_table)
-        if node.title?
-          xml_table.name do |n|
-            n << node.title
-          end
-        end
+        block_title(node, xml_table)
       end
 
       def table_cell1(cell)
@@ -67,7 +63,7 @@ module Metanorma
         %i(head body foot).reject { |s| node.rows[s].empty? }.each do |s|
           xml.send "t#{s}" do |xml_tblsec|
             node.rows[s].each do |row|
-              xml_tblsec.tr do |xml_tr|
+              xml_tblsec.tr **attr_code(id_attr(nil)) do |xml_tr|
                 row.each { |cell| table_cell(cell, xml_tr, s) }
               end
             end

data/lib/metanorma/standoc/term_lookup_cleanup.rb

@@ -16,13 +16,11 @@ module Metanorma
         @unique_designs = {}
         @c = HTMLEntities.new
         @terms_tags = xmldoc.xpath("//terms").each_with_object({}) do |t, m|
-          #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
@@ -72,11 +70,8 @@ module Metanorma
       end
 
       def populate_idhash
-        #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
@@ -213,21 +208,17 @@ 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["anchor"]).nil? && !node["anchor"].nil?
           id = unique_text_id(term_text, prefix)
-          #node["id"] = id
           node["anchor"] = id
           @idhash[id] = true
         end
-        #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["anchor"]
         end
       end

data/lib/metanorma/standoc/terms.rb

@@ -24,7 +24,7 @@ module Metanorma
       def symbols_parse(attr, xml, node)
         node.role == "nonterm" and return nonterm_symbols_parse(attr, xml, node)
         xml.definitions **attr_code(attr) do |xml_section|
-          xml_section.title { |t| t << node.title }
+          section_title(xml_section, node.title)
           stash_symbols
           @definitions = true
           stash_term_def
@@ -98,7 +98,7 @@ module Metanorma
 
       def term_def_parse(attrs, xml, node, _toplevel)
         xml.terms **attr_code(attrs) do |section|
-          section.title { |t| t << node.title }
+          section_title(section, node.title)
           (s = node.attr("source")) && s.split(",").each do |s1|
             section.termdocsource(nil, **attr_code(bibitemid: s1))
           end
@@ -166,7 +166,8 @@ module Metanorma
 
       def termdefinition(node)
         noko do |xml|
-          xml.definition **attr_code(type: node.attr("type")) do |d|
+          xml.definition **attr_code(id_attr(nil)
+            .merge(type: node.attr("type"))) do |d|
             d << node.content
           end
         end

data/lib/metanorma/standoc/utils.rb

@@ -39,6 +39,10 @@ module Metanorma
         node["id"] = "_#{UUIDTools::UUID.random_create}"
       end
 
+      def add_id_text
+        %(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) }

data/lib/metanorma/standoc/version.rb

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

data/metanorma-standoc.gemspec

@@ -34,9 +34,8 @@ Gem::Specification.new do |spec|
   spec.add_dependency "iev", "~> 0.3.5"
   spec.add_dependency "isodoc", "~> 3.1.4"
   spec.add_dependency "metanorma", ">= 1.6.0"
-  spec.add_dependency "metanorma-plugin-datastruct", "~> 0.3.0"
   spec.add_dependency "metanorma-plugin-glossarist", "~> 0.2.3"
-  spec.add_dependency "metanorma-plugin-lutaml", "~> 0.7.0"
+  spec.add_dependency "metanorma-plugin-lutaml", "~> 0.7.31"
   spec.add_dependency "metanorma-utils", "~> 1.11.0"
   spec.add_dependency "ruby-jing"
   # relaton-cli not just relaton, to avoid circular reference in metanorma