metanorma-standoc 3.2.4 → 3.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ec17f7140bc90f4bf870ab2ecf47e42adacc489e4e5dfc8802dbbea87a31973f
-  data.tar.gz: 3da2d1e8a995ebc3d5fb5fe10694cd1094343261e58667007250ed07dde5ea1b
+  metadata.gz: 8ebe9c752511841d783fa0d9820ee7bd26448703e6990bbd406ae0d92ab35417
+  data.tar.gz: b6e82ef1d270969216902f745314145917cbdc376fe92fe11b76964cdd8bb6f1
 SHA512:
-  metadata.gz: 44afc48d384a6c8685b223feaa5905a56cc1d3ee9b572abd221b839be690698d73bb253539abe8f4ece2810185ebd6dc64321a0aa7335007a6384ad4fbea2f18
-  data.tar.gz: dc1ef34776bca5944dec22bad965498970de309848b4fb9c9370dfe303490d57b5dceedae26bac8f0b5cce7642318a607c613fa0044ba10e5fd6b58972ed9a3e
+  metadata.gz: 7b35e03b90cf332d1c100003d1e5bd72a524ffb085eb3b85428ebaac975f51d69562404e31f761894b22d51a9245be804f27a6e230299ed904ab497ebfc1d3c5
+  data.tar.gz: 29a42e39bbc67f18b07d557f32da4dbd3a6747f913108b4cfa2a74f610484cfd114d127e78fe8b21e4bf45ef255de955947967402f78d4f4cf3bfb07b77a6694

data/lib/isodoc/html/htmlstyle.css

@@ -624,7 +624,7 @@ body pre * {
   }
 }
 
-div.figure .FigureTitle, div.figure .figure-title {
+div.figure figcaption {
   font-weight: 700;
   font-size: 1em;
   text-align: center;
@@ -1066,8 +1066,12 @@ table th, table td {
 table td.header {
   font-weight: 400;
 }
+table table.plain, table table.plain th, table table.plain td {
+  border: none !important;
+  font-size: 0.95em;
+}
 
-p.TableTitle {
+table > caption {
   text-align: center;
   margin-top: 2.5em;
   font-weight: 400;

data/lib/isodoc/html/htmlstyle.scss

@@ -368,7 +368,7 @@ table {
   @include table(1px solid black);
 }
 
-p.TableTitle {
+table > caption {
   text-align: center;
   margin-top: 2.5em;
   font-weight: 400;

data/lib/metanorma/cleanup/amend.rb

@@ -0,0 +1,78 @@
+module Metanorma
+  module Standoc
+    module Amend
+      def change_clauses(docxml)
+        docxml.xpath("//clause[@change]").each do |c|
+          create_amend(c)
+        end
+      end
+
+      def create_amend(clause)
+        a = clause.add_child("<amend/>").first
+        add_id(a)
+        clause.elements.each do |e|
+          e.parent = a unless %w(amend title).include? e.name
+        end
+        create_amend1(clause, a)
+      end
+
+      def create_amend1(clause, amend)
+        create_amend2(clause, amend)
+        move_attrs_to_amend(clause, amend)
+        create_amend_autonum(amend)
+        amend
+      end
+
+      def create_amend_autonum(amend)
+        autonum = (amend.xpath(".//autonumber") -
+                   amend.xpath(".//clause//autonumber")).map(&:remove)
+        amend.xpath(".//p[normalize-space(.)='']").each(&:remove)
+        ins = amend.children.first
+        autonum.each { |a| ins.previous = a }
+        (amend.xpath(".//clause") - amend.xpath(".//clause/clause")).each do |c|
+          create_amend_autonum(c)
+        end
+      end
+
+      # possible formats: DESC? BLOCKQUOTE DESC?; DESC? BLOCKQUOTE? SUBCLAUSES+
+      def create_amend2(clause, amend)
+        q, pre, post = create_amend2_prep(clause, amend)
+        if q.empty?
+          amend.children = "<description>#{amend.children.to_xml}</description>"
+          return
+        end
+        ins = amend.add_child("<newcontent/>").first
+        q.each { |n| ins << n.remove }
+        pre.empty? or ins.previous = "<description>#{pre.to_xml}</description>"
+        post.empty? or ins.next = "<description>#{post.to_xml}</description>"
+      end
+
+      def create_amend2_prep(_clause, amend)
+        ret = amend.xpath("./quote[1]")
+        ret += amend.xpath("./clause")
+        ret.empty? and return [[], nil, nil]
+        pre = ret[0].xpath("./preceding-sibling::*").each(&:remove)
+        post = ret[-1].xpath("./following-sibling::*").each(&:remove)
+        ret[0].name == "quote" and ret = ret[0].remove.children + ret[1..]
+        [ret, pre, post]
+      end
+
+      def move_attrs_to_amend(clause, amend)
+        %w(change path path_end title).each do |e|
+          clause[e] or next
+          amend[e] = clause[e]
+          clause.delete(e)
+        end
+        move_attrs_to_amend_locality(clause, amend)
+      end
+
+      def move_attrs_to_amend_locality(_clause, amend)
+        amend["locality"] or return
+        loc = amend.children.add_previous_sibling("<location/>")
+        extract_localities1(loc, amend["locality"])
+        loc1 = loc.at("./localityStack") and loc.replace(loc1.elements)
+        amend.delete("locality")
+      end
+    end
+  end
+end

data/lib/metanorma/{standoc/cleanup_asciibib.rb → cleanup/asciibib.rb}

@@ -2,7 +2,7 @@ require "relaton_bib"
 
 module Metanorma
   module Standoc
-    module Cleanup
+    module Asciibib
       def ref_dl_cleanup(xmldoc)
         xmldoc.xpath("//clause[@bibitem = 'true']").each do |c|
           bib = dl_bib_extract(c) or next

data/lib/metanorma/{standoc/cleanup_attachment.rb → cleanup/attachment.rb}

@@ -1,6 +1,6 @@
 module Metanorma
   module Standoc
-    module Cleanup
+    module Attachment
       def attachment_cleanup(xmldoc)
         xmldoc.xpath("//bibitem[uri/@type = 'attachment']").each do |b|
           b["hidden"] = "true"

data/lib/metanorma/{standoc/cleanup_bibdata.rb → cleanup/bibdata.rb}

@@ -1,6 +1,6 @@
 module Metanorma
   module Standoc
-    module Cleanup
+    module Bibdata
       def bibdata_cleanup(xmldoc)
         bibdata_anchor_cleanup(xmldoc)
         bibdata_docidentifier_cleanup(xmldoc)
@@ -16,8 +16,8 @@ module Metanorma
            backpage-image).each do |n|
              xmldoc.xpath("//bibdata/ext/#{n}").each do |x|
                ins = add_misc_container(xmldoc)
-               ins << "<presentation-metadata><name>#{n}</name>" \
-                      "<value>#{x.remove.children.to_xml}</value>" \
+               ins << "<presentation-metadata><#{n}>" \
+                      "#{x.remove.children.to_xml}</#{n}>" \
                       "</presentation-metadata>"
              end
            end
@@ -42,8 +42,8 @@ module Metanorma
       def gather_indirect_erefs(xmldoc, prefix)
         xmldoc.xpath("//eref[@type = '#{prefix}']")
           .each_with_object({}) do |e, m|
-          e.delete("type")
-          m[e["bibitemid"]] = true
+            e.delete("type")
+            m[e["bibitemid"]] = true
         end.keys
       end
 
@@ -96,7 +96,7 @@ module Metanorma
         # (which is what bibitemid currently points to)
         id_map = xmldoc.xpath("//*[@anchor]")
           .each_with_object({}) do |node, map|
-          map[node["anchor"]] = node
+            map[node["anchor"]] = node
         end
         # Pre-index all <eref> elements by bibitemid
         eref_map = xmldoc.xpath("//eref[@bibitemid]")
@@ -120,7 +120,7 @@ module Metanorma
       end
 
       def hdr2bibitem(hdr)
-        xml = isolated_asciidoctor_convert(hdr[:text],
+        xml = @conv.isolated_asciidoctor_convert(hdr[:text],
                                            backend: hdr2bibitem_type(hdr),
                                            header_footer: true)
         b = Nokogiri::XML(xml).at("//xmlns:bibdata")
@@ -154,7 +154,7 @@ module Metanorma
             bibdata.at("./docidentifier")
           xmldoc.xpath("//xref[@target = '#{d}'][normalize-space(.//text()) = '']")
             .each do |x|
-            x << ident.text
+              x << ident.text
           end
         end
       end
@@ -190,12 +190,19 @@ module Metanorma
         ins = add_misc_container(xmldoc)
         ins ||= add_misc_container(xmldoc)
         ins.at("./semantic-metadata/stage-published") and return
-        p = published?(xmldoc.at("bibdata/status/stage")&.text, xmldoc)
+        p = published_base?(xmldoc.at("bibdata/status/stage")&.text, xmldoc)
         ins << <<~XML
           <semantic-metadata><stage-published>#{p}</stage-published></semantic-metadata>
         XML
       end
 
+      def published_base?(stage, _xmldoc)
+        if @stage_published
+          @stage_published == "true"
+        else published?(stage, _xmldoc)
+        end
+      end
+
       def published?(stage, _xmldoc)
         stage.casecmp("published").zero?
       end
@@ -215,6 +222,8 @@ module Metanorma
           p.nil? || p.text.strip.empty? and c.remove
         end
       end
+
+      def docidentifier_cleanup(xmldoc); end
     end
   end
 end

data/lib/metanorma/{standoc/cleanup_bibitem.rb → cleanup/bibitem.rb}

@@ -1,8 +1,10 @@
-require_relative "cleanup_attachment"
+require_relative "attachment"
 
 module Metanorma
   module Standoc
-    module Cleanup
+    module Bibitem
+      include Attachment
+
       def formattedref_spans(xmldoc)
         xmldoc.xpath("//bibitem[formattedref//span]").each do |b|
           ret = new_bibitem_from_formattedref_spans(b)
@@ -14,7 +16,7 @@ module Metanorma
       end
 
       def new_bibitem_from_formattedref_spans(bib)
-        ret = SpansToBibitem.new(bib).convert
+        ret = Metanorma::Standoc::Cleanup::SpansToBibitem.new(bib).convert
         ret.err.each do |e|
           @log.add(e[:fatal] ? "STANDOC_52" : "STANDOC_53",
                    bib, params: [e[:msg]])
@@ -26,7 +28,7 @@ module Metanorma
         merge_bibitem_from_formattedref_span_attrs(bib, new)
         if bib.at("./title") && bib["amend"]
           # there already is a fetched record here: merge
-          bib.children = MergeBibitems
+          bib.children = Metanorma::Standoc::Cleanup::MergeBibitems
             .new(bib.to_xml, new.to_xml).merge.to_noko.children
         elsif bib.at("./title") # replace record
           bib.children = new.children.to_xml
@@ -135,11 +137,11 @@ module Metanorma
       def fetch_local_bibitem(xmldoc)
         xmldoc.xpath("//bibitem[formattedref][uri[@type = 'citation']]")
           .each do |b|
-          uri = b&.at("./uri[@type = 'citation']")&.text
-          bibitem = read_local_bibitem(uri) or next
-          bibitem["id"] = b["id"]
-          bibitem["anchor"] = b["anchor"]
-          b.replace(bibitem)
+            uri = b&.at("./uri[@type = 'citation']")&.text
+            bibitem = read_local_bibitem(uri) or next
+            bibitem["id"] = b["id"]
+            bibitem["anchor"] = b["anchor"]
+            b.replace(bibitem)
         end
       end
 

data/lib/metanorma/{standoc/cleanup_block.rb → cleanup/block.rb}

@@ -3,7 +3,7 @@ require "htmlentities"
 
 module Metanorma
   module Standoc
-    module Cleanup
+    module Block
       def para_cleanup(xmldoc)
         ["//p[not(ancestor::bibdata)]", "//ol[not(ancestor::bibdata)]",
          "//ul[not(ancestor::bibdata)]", "//quote[not(ancestor::bibdata)]",
@@ -21,6 +21,23 @@ module Metanorma
         end
       end
 
+      def key_cleanup(xmldoc)
+        xmldoc.xpath("//*[@key = 'true']").each do |x|
+          x.delete("key")
+          x.replace("<key>#{to_xml(x)}</key>")
+        end
+        key_concatenate(xmldoc)
+        xmldoc.xpath("//key//key").each { |x| x.replace(x.children) }
+      end
+
+      def key_concatenate(xmldoc)
+        xmldoc.xpath("//key").each do |x|
+          while x.next_element&.name == "key"
+            x << x.next_element.remove.children
+          end
+        end
+      end
+
       # include where definition list inside stem block
       def formula_cleanup(formula)
         formula_cleanup_where1(formula)
@@ -28,49 +45,44 @@ module Metanorma
       end
 
       def formula_cleanup_where1(formula)
-        q = "//formula/following-sibling::*[1][self::dl]"
+        q = "//formula/following-sibling::*[1][self::key]"
         formula.xpath(q).each do |s|
-          s["key"] == "true" and s.previous_element << s.remove
+          s.previous_element << s.remove
         end
       end
 
       def formula_cleanup_where2(formula)
-        q = "//formula/following-sibling::*[1][self::p]"
-        formula.xpath(q).each do |s|
-          if s.text =~ /^\s*where[^a-z]*$/i && s&.next_element&.name == "dl"
-            s.next_element["key"] = "true"
-            s.previous_element << s.next_element.remove
+        text_key_extract(formula, "formula", "where")
+      end
+
+      def text_key_extract(elem, tag, keywd)
+        q = "//#{tag}/following-sibling::*[1][self::p]"
+        elem.xpath(q).each do |s|
+          if s.text =~ /^\s*#{keywd}[^a-z]*$/i && s&.next_element&.name == "dl"
+            s.previous_element << "<key>#{to_xml(s.next_element.remove)}</key>"
             s.remove
           end
         end
       end
 
       def figure_dl_cleanup1(xmldoc)
-        q = "//figure/following-sibling::*[self::dl]"
-        q1 = "//figure/figure/following-sibling::*[self::dl]"
+        q = "//figure/following-sibling::*[self::key]"
+        q1 = "//figure/figure/following-sibling::*[self::key]"
         (xmldoc.xpath(q) - xmldoc.xpath(q1)).each do |s|
-          s["key"] == "true" and s.previous_element << s.remove
+          s.previous_element << s.remove
         end
       end
 
       # include key definition list inside figure
       def figure_dl_cleanup2(xmldoc)
-        q = "//figure/following-sibling::*[self::p]"
-        xmldoc.xpath(q).each do |s|
-          if s.text =~ /^\s*key[^a-z]*$/i && s&.next_element&.name == "dl"
-            s.next_element["key"] = "true"
-            s.previous_element << s.next_element.remove
-            s.remove
-          end
-        end
+        text_key_extract(xmldoc, "figure", "key")
       end
 
       # examples containing only figures become subfigures of figures
       def subfigure_cleanup(xmldoc)
         xmldoc.xpath("//example[figure]").each do |e|
           e.elements.reject do |m|
-            %w(name figure index note).include?(m.name) ||
-              (m.name == "dl" && m["key"] == "true")
+            %w(name figure index note key).include?(m.name)
           end.empty? or next
           e.name = "figure"
         end
@@ -115,7 +127,7 @@ module Metanorma
       def note_cleanup(xmldoc)
         xmldoc.xpath("//note").each do |n|
           n["keep-separate"] == "true" || !n.ancestors("table").empty? and next
-          prev = n.previous_element || next
+          prev = n.previous_element or next
           n.parent = prev if ELEMS_ALLOW_NOTES.include? prev.name
         end
         xmldoc.xpath("//note[@keep-separate] | " \
@@ -172,61 +184,36 @@ module Metanorma
       end
 
       def sourcecode_markup(node)
-        node.text.split(/(#{Regexp.escape(@sourcecode_markup_start)}|
-                          #{Regexp.escape(@sourcecode_markup_end)})/x)
-          .each_slice(4).map.with_object([]) do |a, acc|
+        source_markup_prep(node).each_slice(4).map.with_object([]) do |a, acc|
           acc << safe_noko(a[0], node.document)
           a.size == 4 or next
-          acc << isolated_asciidoctor_convert(
-            a[2], doctype: :inline, backend: backend&.to_sym || :standoc
-          )
+          acc << @conv.isolated_asciidoctor_convert(
+            "{blank} #{a[2]}", doctype: :inline,
+                               backend: @conv.backend&.to_sym || :standoc
+          ).strip
         end.join
       end
 
-      def form_cleanup(xmldoc)
-        xmldoc.xpath("//select").each do |s|
-          while s.next_element&.name == "option"
-            s << s.next_element
-          end
-        end
+      def source_markup_prep(node)
+        ret = node.text.split(/(#{Regexp.escape(@sourcecode_markup_start)}|
+                          #{Regexp.escape(@sourcecode_markup_end)})/x)
+        source_markup_validate(node, ret)
+        ret
       end
 
-      def block_index_cleanup(xmldoc)
-        xmldoc.xpath("//quote | //td | //th | //formula | //li | //dt | " \
-                     "//dd | //example | //note | //figure | //sourcecode | " \
-                     "//admonition | //termnote | //termexample | //form  | " \
-                     "//requirement | //recommendation | //permission | " \
-                     "//imagemap | //svgmap").each do |b|
-          b.xpath("./p[indexterm]").each do |p|
-            indexterm_para?(p) or next
-            p.replace(p.children)
-          end
+      def source_markup_validate(node, ret)
+        ret.each_slice(4) do |a|
+          a.size == 4 or next
+          a[1] == @sourcecode_markup_start && a[3] == @sourcecode_markup_end or
+            @log.add("STANDOC_61", node, params: [a.join])
         end
       end
 
-      def indexterm_para?(para)
-        p = para.dup
-        p.xpath("./index").each(&:remove)
-        p.text.strip.empty?
-      end
-
-      def include_indexterm?(elem)
-        elem.nil? and return false
-        !%w(image literal sourcecode).include?(elem.name)
-      end
-
-      def para_index_cleanup(xmldoc)
-        xmldoc.xpath("//p[index]").select { |p| indexterm_para?(p) }
-          .each do |p|
-            para_index_cleanup1(p, p.previous_element, p.next_element)
+      def form_cleanup(xmldoc)
+        xmldoc.xpath("//select").each do |s|
+          while s.next_element&.name == "option"
+            s << s.next_element
           end
-      end
-
-      def para_index_cleanup1(para, prev, foll)
-        if include_indexterm?(prev)
-          prev << para.remove.children
-        elsif include_indexterm?(foll) # && !foll.children.empty?
-          foll.add_first_child para.remove.children
         end
       end
 

data/lib/metanorma/{standoc/cleanup_boilerplate.rb → cleanup/boilerplate.rb}

@@ -1,8 +1,9 @@
-require_relative "cleanup_terms_boilerplate"
+require_relative "terms_boilerplate"
+require_relative "boilerplate_liquid"
 
 module Metanorma
   module Standoc
-    module Cleanup
+    module Boilerplate
       def norm_ref_preface(ref, isodoc)
         ins = norm_ref_boilerplate_insert_location(ref)
         ins2 = norm_ref_process_boilerplate_note(ref)
@@ -36,13 +37,9 @@ module Metanorma
         ref.at("./title")
       end
 
-      NORM_REF =
-        "//bibliography/references[@normative = 'true'][not(@hidden)] | " \
-        "//bibliography/clause[.//references[@normative = 'true']]".freeze
-
       def dup_with_namespace(elem)
         ret = elem.dup
-        ret.add_namespace(nil, xml_namespace)
+        ret.add_namespace(nil, @conv.xml_namespace)
         ret
       end
 
@@ -51,7 +48,8 @@ module Metanorma
         # in termdef_boilerplate_insert and initial_boilerplate
         xmldoc.at("//metanorma-extension/semantic-metadata/" \
                   "headless[text() = 'true']") and return nil
-        @isodoc ||= isodoc(@lang, @script, @locale)
+        @isodoc ||= @conv.isodoc(@lang, @script, @locale)
+        @i18n = @isodoc.i18n
         isodoc_bibdata_parse(xmldoc)
         @isodoc
       end
@@ -75,7 +73,7 @@ module Metanorma
 
       def boilerplate_cleanup(xmldoc)
         isodoc = boilerplate_isodoc(xmldoc) or return
-        # boilerplate_isodoc_values(isodoc)
+        docidentifier_boilerplate_isodoc(xmldoc, isodoc)
         termdef_boilerplate_cleanup(xmldoc)
         termdef_boilerplate_insert(xmldoc, isodoc)
         unwrap_boilerplate_clauses(xmldoc, self.class::TERM_CLAUSE)
@@ -86,6 +84,17 @@ module Metanorma
         initial_boilerplate(xmldoc, isodoc)
       end
 
+      def docidentifier_boilerplate_isodoc(xmldoc, isodoc)
+        xmldoc.xpath("//docidentifier[@boilerplate]").each do |d|
+          b = d["boilerplate"] == "true"
+          d.delete("boilerplate")
+          b or next
+          id = boilerplate_snippet_convert(to_xml(d.children), isodoc)
+          p = Nokogiri::XML(id).at("//p")
+          d.children = p ? to_xml(p&.children) : id
+        end
+      end
+
       def initial_boilerplate(xml, isodoc)
         xml.at("//boilerplate") and return
         preface = xml.at("//preface | //sections | //annex | //references") or
@@ -170,68 +179,6 @@ module Metanorma
         end
       end
 
-      # The boilerplate file is in Liquid AsciiDoc format
-      # (technically, `boilerplate.adoc.liquid`).
-      #
-      # This file is processed separately from the main Metanorma document and
-      # therefore is oblivious of the `{{ concept-mention }}` syntax.
-      #
-      # Due to historic reasons, the Liquid objects being evaluated in the
-      # boilerplate document are XML strings. Notably these are the document
-      # metadata, that are extracted from the already generated Metanorma XML.
-      #
-      # These XML strings are then passed into the AsciiDoc macros such as
-      # `span:publisher[...]`.
-      #
-      # Here, we need to interpolate the XML strings into the AsciiDoc macros
-      # without breaking the AsciiDoc syntax.
-      #
-      # EXAMPLE 1: `mailto:{{ pub_email }}[]`, we need to
-      # convert it to:
-      # `mailto:{{ pass-format:metanorma[++pub_email_xml++] }}[]`
-      #
-      # EXAMPLE 2: `link:{{ pub_uri}}[{{ pub_address }}, {{ pub_uri }}]`
-      # We need to convert it to:
-      # `link:{{ pass-format:metanorma[++pub_uri_xml++] }}[{{
-      # pass-format:metanorma[++pub_address_xml++] }}, {{
-      # pass-format:metanorma[++pub_uri_xml++] }}]`
-      #
-      # NOTE: The boilerplate may use macros that contain one or more
-      # `{{ ... }}` in the target, and can contain spaces in them.
-      #
-      # NOTE: The routine needs to handle cases where the content
-      # contains an escaped closing bracket `\]`.
-
-      ADOC_MACRO_PATTERN = /\S+:[^\[\n]*\[[^\]\\]*(?:\\.[^\]\\]*)*\]/
-
-      # Replace {{ ... }} with {{ pass-format:metanorma:[...] }} to preserve any
-      # XML markup provided by Metanorma XML Metadata content, through the
-      # `pass-format:metanorma` command.
-      #
-      # * If `{{ ... }}` is inside an Asciidoc macro, we have to wrap with
-      #   pass-format:metanorma:[...\].
-      # * If this is a macro target (e.g. `mailto:{{x}}[]`, body: mailto:[{{x}}])
-      #   then do not use pass-format:metanorma.
-
-      def boilerplate_read(file)
-        ret = File.read(file, encoding: "UTF-8")
-        /\.adoc(\.liquid)?$/.match?(file) or return ret
-
-        # Split content into macro and non-macro parts
-        parts = ret.split(/(#{ADOC_MACRO_PATTERN})/o)
-
-        parts.map.with_index do |part, index|
-          if index.odd? && valid_macro?(part)
-            # This is a macro - leave unchanged
-            part
-          else
-            # Not a macro - wrap {{ }} patterns
-            part.gsub(/(?<!\{)(\{\{[^{}]+\}\})(?!\})/,
-                      "pass-format:metanorma[++\\1++]")
-          end
-        end.join
-      end
-
       # If Asciidoctor, convert top clauses to tags and wrap in <boilerplate>
       def boilerplate_file_convert(file)
         ret = Nokogiri::XML(file).root and return ret
@@ -239,20 +186,21 @@ module Metanorma
       end
 
       def boilerplate_file_restructure(file)
-        ret = adoc2xml(file, backend.to_sym)
+        ret = adoc2xml(file, @conv.backend.to_sym)
         boilerplate_xml_cleanup(ret)
         ret.name = "boilerplate"
         boilerplate_top_elements(ret)
         ret
       end
 
-      private
-
-      def valid_macro?(text)
-        # Simple validation - does it look like a macro?
-        text.match?(/^\S+:[^\[]*\[.*\]$/)
+      def boilerplate_snippet_convert(adoc, isodoc)
+        b = isodoc.populate_template(adoc, nil)
+        ret = boilerplate_xml_cleanup(adoc2xml(b, @conv.backend.to_sym))
+        @i18n.l10n(ret.children.to_xml, @lang, @script).strip
       end
 
+      private
+
       # remove Metanorma namespace, so generated doc containing boilerplate
       # can be queried consistently
       # _\d+ anchor is assigned to titleless clauses, will clash with main doc