metanorma-standoc 2.9.5 → 2.9.7

data/lib/metanorma/standoc/blocks.rb

@@ -77,7 +77,7 @@ module Metanorma
       def stem(node)
         noko do |xml|
           xml.formula **formula_attrs(node) do |s|
-            stem_parse(node.lines.join("\n"), s, node.style.to_sym, node.block?)
+            stem_parse(node.lines.join("\n"), s, node.style.to_sym, node)
           end
         end
       end

data/lib/metanorma/standoc/cleanup.rb

@@ -54,6 +54,7 @@ module Metanorma
         normref_cleanup(xmldoc)
         biblio_cleanup(xmldoc)
         reference_names(xmldoc)
+        terms_terms_cleanup(xmldoc) # feeds: boilerplate_cleanup
         asciimath_cleanup(xmldoc) # feeds: mathml_cleanup, termdef_cleanup,
         # symbols_cleanup
         symbols_cleanup(xmldoc) # feeds: termdef_cleanup
@@ -77,9 +78,10 @@ module Metanorma
         docidentifier_cleanup(xmldoc) # feeds: bibdata_cleanup
         ext_contributor_cleanup(xmldoc) # feeds: bibdata_cleanup
         ext_dochistory_cleanup(xmldoc) # feeds: bibdata_cleanup
-        bibdata_cleanup(xmldoc)
+        bibdata_cleanup(xmldoc) # feeds: boilerplate_cleanup
+        boilerplate_cleanup(xmldoc) # feeds: xref_cleanup for new <<>> introduced
+        xref_cleanup(xmldoc)
         svgmap_cleanup(xmldoc) # feeds: img_cleanup
-        boilerplate_cleanup(xmldoc)
         toc_cleanup(xmldoc)
         smartquotes_cleanup(xmldoc)
         linebreak_cleanup(xmldoc)

data/lib/metanorma/standoc/cleanup_bibitem.rb

@@ -142,34 +142,46 @@ module Metanorma
           u = b.at("./uri[@type = 'attachment']")
           c = b.at("./uri[@type = 'citation']") ||
             u.after("<uri type='citation'/>")
-          uri = save_attachment(u.text, b)
+          uri = attachment_uri(u.text, b)
           u.children = uri
           c.children = uri
         end
       end
 
-      def save_attachment(path, bib)
+      def attachment_uri(path, bib)
         init_attachments
         path = File.join(@localdir, path)
         valid_attachment?(path, bib) or return ""
+        @datauriattachment or return attachment_location(path)
+        save_attachment(path, bib)
+      end
+
+      def save_attachment(path, bib)
+        init_attachments
         f = File.basename(path)
         File.exist?(File.join(@attachmentsdir, f)) and
           f += "_#{UUIDTools::UUID.random_create}"
         out_fld = File.join(@attachmentsdir, f)
         FileUtils.cp(path, out_fld)
         datauri_attachment(out_fld, bib.document)
-        File.join(@attachmentsfld, f)
+      end
+
+      def attachment_location(path)
+        f = path
+        @datauriattachment and
+          f = File.join(@attachmentsdir, File.basename(path))
+        Pathname.new(File.expand_path(f))
+          .relative_path_from(Pathname.new(File.expand_path(@localdir))).to_s
       end
 
       def datauri_attachment(path, doc)
         @datauriattachment or return
         m = add_misc_container(doc)
-        f = File.join(@attachmentsdir, File.basename(path))
-        f = Pathname.new(File.expand_path(f))
-          .relative_path_from(Pathname.new(File.expand_path(@localdir)))
+        f = attachment_location(path)
         e = (m << "<attachment name='#{f}'/>").last_element_child
         Vectory::Utils::datauri(path, @localdir).scan(/.{1,60}/)
           .each { |dd| e << "#{dd}\n" }
+        f
       end
 
       def valid_attachment?(path, bib)

data/lib/metanorma/standoc/cleanup_boilerplate.rb

@@ -1,41 +1,8 @@
+require_relative "cleanup_terms_boilerplate"
+
 module Metanorma
   module Standoc
     module Cleanup
-      def external_terms_boilerplate(sources)
-        e = @i18n.external_terms_boilerplate
-        @i18n.l10n(e.gsub(/%(?=\p{P}|\p{Z}|$)/, sources || "???"),
-                   @lang, @script, @locale)
-      end
-
-      def internal_external_terms_boilerplate(sources)
-        e = @i18n.internal_external_terms_boilerplate
-        @i18n.l10n(e.gsub(/%(?=\p{P}|\p{Z}|$)/, sources || "??"),
-                   @lang, @script)
-      end
-
-      def term_defs_boilerplate(div, source, term, _preface, isodoc)
-        a = @i18n.term_def_boilerplate and div.next = a
-        source.each do |s|
-          @anchors[s["bibitemid"]] or
-            @log.add("Crossreferences", nil,
-                     "term source #{s['bibitemid']} not referenced", severity: 1)
-        end
-        a = if source.empty? && term.nil? then @i18n.no_terms_boilerplate
-            else term_defs_boilerplate_cont(source, term, isodoc)
-            end and div.next = a
-      end
-
-      def term_defs_boilerplate_cont(src, term, isodoc)
-        sources = isodoc.sentence_join(src.map do |s|
-          %{<eref bibitemid="#{s['bibitemid']}"/>}
-        end)
-        if src.empty? then @i18n.internal_terms_boilerplate
-        elsif term.nil? then external_terms_boilerplate(sources)
-        else
-          internal_external_terms_boilerplate(sources)
-        end
-      end
-
       def norm_ref_preface(ref)
         ins = norm_ref_boilerplate_insert_location(ref)
         ins2 = norm_ref_process_boilerplate_note(ref)
@@ -45,7 +12,7 @@ module Metanorma
           %w(references bibitem).include? e.name
         end
         pref = refs.empty? ? @i18n.norm_empty_pref : @i18n.norm_with_refs_pref
-        ins.next = "<p>#{pref}</p>"
+        ins.next = boilerplate_snippet_convert(pref)
       end
 
       def norm_ref_process_boilerplate_note(ref)
@@ -69,16 +36,15 @@ module Metanorma
         ref.at("./title")
       end
 
-      TERM_CLAUSE =
-        "//sections//terms[not(.//ancestor::clause[@type = 'terms'])] | " \
-        "//sections/clause[descendant::terms][@type = 'terms'] | " \
-        "//sections/clause[not(@type = 'terms')]//terms".freeze
-
       NORM_REF =
         "//bibliography/references[@normative = 'true'][not(@hidden)] | " \
         "//bibliography/clause[.//references[@normative = 'true']]".freeze
 
       def boilerplate_isodoc(xmldoc)
+        # prevent infinite recursion of asciidoc boilerplate processing
+        # in termdef_boilerplate_insert and initial_boilerplate
+        xmldoc.at("//metanorma-extension/semantic-metadata/" \
+                  "headless[text() = 'true']") and return nil
         x = xmldoc.dup
         x.root.add_namespace(nil, self.class::XML_NAMESPACE)
         xml = Nokogiri::XML(x.to_xml)
@@ -87,14 +53,6 @@ module Metanorma
         @isodoc
       end
 
-      def termdef_boilerplate_cleanup(xmldoc)
-        # termdef_remove_initial_paras(xmldoc)
-      end
-
-      def termdef_remove_initial_paras(xmldoc)
-        xmldoc.xpath("//terms/p | //terms/ul").each(&:remove)
-      end
-
       def unwrap_boilerplate_clauses(xmldoc, xpath)
         xmldoc.xpath(xpath).each do |f|
           f.xpath(".//clause[@type = 'boilerplate'] | " \
@@ -105,51 +63,8 @@ module Metanorma
         end
       end
 
-      def termdef_boilerplate_insert(xmldoc, isodoc, once = false)
-        if once
-          f = termdef_boilerplate_insert_location(xmldoc) and
-            termdef_boilerplate_insert1(f, xmldoc, isodoc)
-        else
-          xmldoc.xpath(self.class::TERM_CLAUSE).each do |f|
-            termdef_boilerplate_insert1(f, xmldoc, isodoc)
-          end
-        end
-      end
-
-      def termdef_boilerplate_insert_location(xmldoc)
-        f = xmldoc.at(self.class::TERM_CLAUSE)
-        root = xmldoc.at("//sections/terms | //sections/clause[@type = 'terms']")
-        if f && root && f["id"] != root["id"]
-          f = termdef_boilerplate_climb_up(f, root)
-        elsif !f && root then f = root
-        end
-        f
-      end
-
-      def termdef_boilerplate_climb_up(clause, container)
-        container.at(".//*[@id = '#{clause['id']}']") or return clause
-        while (n = clause.parent)
-          n.at(".//definitions") and break
-          clause = n
-          n["id"] == container["id"] and break
-        end
-        clause
-      end
-
-      def termdef_boilerplate_insert1(sect, xmldoc, isodoc)
-        ins = sect.at("./title")
-        if (ins2 = sect.at("./clause[@type = 'boilerplate'] | " \
-                "./note[@type = 'boilerplate']"))
-          ins2.text.strip.downcase == "(default)" or return
-          ins2.children = " "
-          ins = ins2.children.first
-        end
-        term_defs_boilerplate(ins, xmldoc.xpath(".//termdocsource"),
-                              sect.at(".//term"), sect.at(".//p"), isodoc)
-      end
-
       def boilerplate_cleanup(xmldoc)
-        isodoc = boilerplate_isodoc(xmldoc)
+        isodoc = boilerplate_isodoc(xmldoc) or return
         termdef_boilerplate_cleanup(xmldoc)
         termdef_boilerplate_insert(xmldoc, isodoc)
         unwrap_boilerplate_clauses(xmldoc, self.class::TERM_CLAUSE)
@@ -245,6 +160,7 @@ module Metanorma
           /^_\d+$/.match?(n["id"]) and
             n["id"] = "_#{UUIDTools::UUID.random_create}"
         end
+        xml
       end
 
       def boilerplate_top_elements(xml)

data/lib/metanorma/standoc/cleanup_inline.rb

@@ -99,7 +99,7 @@ module Metanorma
       def key_extract_locality(elem)
         elem["key"].include?(",") or return
         elem.add_child("<locality>#{elem['key'].sub(/^[^,]+,/, '')}</locality>")
-        elem["key"] = elem["key"].sub(/,.*$/, "")
+        elem["key"] = elem["key"].sub(/(^[^,]+),.*$/, "\\1")
       end
 
       def concept_termbase_cleanup(elem)

data/lib/metanorma/standoc/cleanup_maths.rb

@@ -1,4 +1,5 @@
 require "asciimath2unitsml"
+require_relative "cleanup_mathvariant"
 
 module Metanorma
   module Standoc
@@ -19,7 +20,7 @@ module Metanorma
       def asciimath2mathml_indiv(elem)
         elem["type"] = "MathML"
         expr = @c.decode(elem.text)
-        ret = asciimath_parse(expr, elem)
+        ret = asciimath_parse(expr, elem)&.strip
         ret += "<asciimath>#{@c.encode(expr, :basic)}</asciimath>"
         elem.children = ret
       rescue StandardError => e
@@ -58,15 +59,19 @@ module Metanorma
         xml
       end
 
-      def progress_conv(idx, step, total, threshold, msg)
-        return unless (idx % step).zero? && total > threshold && idx.positive?
+      def mathml_xml_cleanup(stem)
+        xml_unescape_mathml(stem)
+        mathml_namespace(stem)
+        mathml_preserve_space(stem)
+      end
 
+      def progress_conv(idx, step, total, threshold, msg)
+        (idx % step).zero? && total > threshold && idx.positive? or return
         warn "#{msg} #{idx} of #{total}"
       end
 
       def xml_unescape_mathml(xml)
-        return if xml.children.any?(&:element?)
-
+        xml.children.any?(&:element?) and return
         math = xml.text.gsub("&lt;", "<").gsub("&gt;", ">")
           .gsub("&quot;", '"').gsub("&apos;", "'").gsub("&amp;", "&")
           .gsub(/<[^: \r\n\t\/]+:/, "<").gsub(/<\/[^ \r\n\t:]+:/, "</")
@@ -86,33 +91,6 @@ module Metanorma
         end
       end
 
-      def mathml_mi_italics
-        { uppergreek: true, upperroman: true,
-          lowergreek: true, lowerroman: true }
-      end
-
-      # presuppose multichar mi upright, singlechar mi MathML default italic
-      def mathml_italicise(xml)
-        xml.xpath(".//m:mi[not(ancestor::*[@mathvariant])]",
-                  "m" => MATHML_NS).each do |i|
-          char = @c.decode(i.text)
-          i["mathvariant"] = "normal" if mi_italicise?(char)
-        end
-      end
-
-      def mi_italicise?(char)
-        char.length > 1 and return false
-        case char
-        when /\p{Greek}/
-          (/\p{Lower}/.match(char) && !mathml_mi_italics[:lowergreek]) ||
-            (/\p{Upper}/.match(char) && !mathml_mi_italics[:uppergreek])
-        when /\p{Latin}/
-          (/\p{Lower}/.match(char) && !mathml_mi_italics[:lowerroman]) ||
-            (/\p{Upper}/.match(char) && !mathml_mi_italics[:upperroman])
-        else false
-        end
-      end
-
       UNITSML_NS = "https://schema.unitsml.org/unitsml/1.0".freeze
 
       def add_misc_container(xmldoc)
@@ -124,9 +102,8 @@ module Metanorma
         ins
       end
 
-      def mathml_unitsML(xmldoc)
-        return unless xmldoc.at(".//m:*", "m" => UNITSML_NS)
-
+      def mathml_unitsml(xmldoc)
+        xmldoc.at(".//m:*", "m" => UNITSML_NS) or return
         misc = add_misc_container(xmldoc)
         unitsml = misc.add_child("<UnitsML xmlns='#{UNITSML_NS}'/>").first
         %w(Unit CountedItem Quantity Dimension Prefix).each do |t|
@@ -139,8 +116,7 @@ module Metanorma
           .each_with_object({}) do |x, m|
           m[x["xml:id"]] = x.remove
         end
-        return if tags.empty?
-
+        tags.empty? and return
         set = unitsml.add_child("<#{tag}Set/>").first
         tags.each_value { |v| set << v }
       end
@@ -149,67 +125,13 @@ module Metanorma
         { multiplier: :space }
       end
 
-      MATHVARIANT_OVERRIDE = {
-        bold: { normal: "bold", italic: "bold-italic", fraktur: "bold-fraktur",
-                script: "bold-script", "sans-serif": "bold-sans-serif",
-                "sans-serif-italic": "sans-serif-bold-italic" },
-        italic: { normal: "italic", bod: "bold-italic",
-                  "sans-serif": "sans-serif-italic",
-                  "bold-sans-serif": "sans-serif-bold-italic" },
-        "bold-italic": { normal: "bold-italic", bold: "bold-italic",
-                         italic: "bold-italic",
-                         "sans-serif": "sans-serif-bold-italic",
-                         "bold-sans-serif": "sans-serif-bold-italic",
-                         "sans-serif-italic": "sans-serif-bold-italic" },
-        fraktur: { normal: "fraktur", bold: "bold-fraktur" },
-        "bold-fraktur": { normal: "bold-fraktur", fraktur: "bold-fraktur" },
-        script: { normal: "script", bold: "bold-script" },
-        "bold-script": { normal: "script", script: "bold-script" },
-        "sans-serif": { normal: "sans-serif", bold: "bold-sans-serif",
-                        italic: "sans-serif-italic",
-                        "bold-italic": "sans-serif-bold-italic" },
-        "bold-sans-serif": { normal: "bold-sans-serif", bold: "bold-sans-serif",
-                             "sans-serif": "bold-sans-serif",
-                             italic: "sans-serif-bold-italic",
-                             "bold-italic": "sans-serif-bold-italic",
-                             "sans-serif-italic": "sans-serif-bold-italic" },
-        "sans-serif-italic": { normal: "sans-serif-italic",
-                               italic: "sans-serif-italic",
-                               "sans-serif": "sans-serif-italic",
-                               bold: "sans-serif-bold-italic",
-                               "bold-italic": "sans-serif-bold-italic",
-                               "sans-serif-bold": "sans-serif-bold-italic" },
-        "sans-serif-bold-italic": { normal: "sans-serif-bold-italic",
-                                    italic: "sans-serif-bold-italic",
-                                    "sans-serif": "sans-serif-bold-italic",
-                                    "sans-serif-italic": "sans-serif-bold-italic",
-                                    bold: "sans-serif-bold-italic",
-                                    "bold-italic": "sans-serif-bold-italic",
-                                    "sans-serif-bold": "sans-serif-bold-italic" },
-      }.freeze
-
-      def mathvariant_override(inner, outer)
-        o = outer.to_sym
-        i = inner.to_sym
-        MATHVARIANT_OVERRIDE[o] or return inner
-        MATHVARIANT_OVERRIDE[o][i] || inner
-      end
-
-      def mathml_mathvariant(math)
-        math.xpath(".//*[@mathvariant]").each do |outer|
-          outer.xpath(".//*[@mathvariant]").each do |inner|
-            inner["mathvariant"] =
-              mathvariant_override(inner["mathvariant"], outer["mathvariant"])
-          end
-        end
-      end
-
       def mathml_mn_format(math)
+        math["number-format"] or return
         math.xpath(".//m:mn", "m" => MATHML_NS).each do |m|
           profile = mathml_mn_profile(m)
           attr = profile.each_with_object([]) do |(k, v), acc|
             v == "nil" and next
-            acc << "#{k}='#{v}'"
+            acc << "#{k}='#{@c.decode v}'"
           end.join(",")
           attr.empty? or m["data-metanorma-numberformat"] = attr
         end
@@ -226,19 +148,47 @@ module Metanorma
         fmt.merge(fmt1).merge(fmt2)
       end
 
+      def mathml_stem_format(stem)
+        f = mathml_stem_format_attr(stem) or return
+        attr = quoted_csv_split(f, ",").map do |x|
+          m = /^(.+?)=(.+)?$/.match(x) or next
+          "#{m[1]}='#{@c.decode m[2]}'"
+        end.join(",")
+        stem.xpath(".//m:mn", "m" => MATHML_NS).each do |m|
+          attr.empty? or m["data-metanorma-numberformat"] = attr
+        end
+      end
+
+      def mathml_stem_format_attr(stem)
+        f = stem["number-format"] || @numberfmt_formula or return
+        if f == "nil"
+          stem.delete("number-format")
+          return
+        end
+        f == "default" or return f
+        if @numberfmt_default.empty?
+          "notation='basic'"
+        else @numberfmt_default&.map { |k, v| "#{k}='#{v}'" }&.join(",")
+        end
+      end
+
+      def mathml_number_format(stem)
+        mathml_stem_format(stem)
+        mathml_mn_format(stem)
+        stem.delete("number-format")
+      end
+
       def mathml_cleanup(xmldoc)
-        unitsml = Asciimath2UnitsML::Conv.new(asciimath2unitsml_options)
+        a2u = Asciimath2UnitsML::Conv.new(asciimath2unitsml_options)
         xmldoc.xpath("//stem[@type = 'MathML'][not(@validate = 'false')]")
           .each do |x|
-          xml_unescape_mathml(x)
-          mathml_namespace(x)
-          mathml_preserve_space(x)
-          unitsml.MathML2UnitsML(x)
+          mathml_xml_cleanup(x)
+          a2u.MathML2UnitsML(x)
           mathml_mathvariant(x)
-          mathml_italicise(x)
-          mathml_mn_format(x)
         end
-        mathml_unitsML(xmldoc)
+        xmldoc.xpath("//stem[@type = 'MathML']")
+          .each { |x| mathml_number_format(x) }
+        mathml_unitsml(xmldoc)
       end
     end
   end

data/lib/metanorma/standoc/cleanup_mathvariant.rb

@@ -0,0 +1,88 @@
+module Metanorma
+  module Standoc
+    module Cleanup
+      def mathml_mi_italics
+        { uppergreek: true, upperroman: true,
+          lowergreek: true, lowerroman: true }
+      end
+
+      # presuppose multichar mi upright, singlechar mi MathML default italic
+      def mathml_italicise(xml)
+        xml.xpath(".//m:mi[not(ancestor::*[@mathvariant])]",
+                  "m" => MATHML_NS).each do |i|
+          char = @c.decode(i.text)
+          i["mathvariant"] = "normal" if mi_italicise?(char)
+        end
+      end
+
+      def mi_italicise?(char)
+        char.length > 1 and return false
+        case char
+        when /\p{Greek}/
+          (/\p{Lower}/.match(char) && !mathml_mi_italics[:lowergreek]) ||
+            (/\p{Upper}/.match(char) && !mathml_mi_italics[:uppergreek])
+        when /\p{Latin}/
+          (/\p{Lower}/.match(char) && !mathml_mi_italics[:lowerroman]) ||
+            (/\p{Upper}/.match(char) && !mathml_mi_italics[:upperroman])
+        else false
+        end
+      end
+
+      MATHVARIANT_OVERRIDE = {
+        bold: { normal: "bold", italic: "bold-italic", fraktur: "bold-fraktur",
+                script: "bold-script", "sans-serif": "bold-sans-serif",
+                "sans-serif-italic": "sans-serif-bold-italic" },
+        italic: { normal: "italic", bod: "bold-italic",
+                  "sans-serif": "sans-serif-italic",
+                  "bold-sans-serif": "sans-serif-bold-italic" },
+        "bold-italic": { normal: "bold-italic", bold: "bold-italic",
+                         italic: "bold-italic",
+                         "sans-serif": "sans-serif-bold-italic",
+                         "bold-sans-serif": "sans-serif-bold-italic",
+                         "sans-serif-italic": "sans-serif-bold-italic" },
+        fraktur: { normal: "fraktur", bold: "bold-fraktur" },
+        "bold-fraktur": { normal: "bold-fraktur", fraktur: "bold-fraktur" },
+        script: { normal: "script", bold: "bold-script" },
+        "bold-script": { normal: "script", script: "bold-script" },
+        "sans-serif": { normal: "sans-serif", bold: "bold-sans-serif",
+                        italic: "sans-serif-italic",
+                        "bold-italic": "sans-serif-bold-italic" },
+        "bold-sans-serif": { normal: "bold-sans-serif", bold: "bold-sans-serif",
+                             "sans-serif": "bold-sans-serif",
+                             italic: "sans-serif-bold-italic",
+                             "bold-italic": "sans-serif-bold-italic",
+                             "sans-serif-italic": "sans-serif-bold-italic" },
+        "sans-serif-italic": { normal: "sans-serif-italic",
+                               italic: "sans-serif-italic",
+                               "sans-serif": "sans-serif-italic",
+                               bold: "sans-serif-bold-italic",
+                               "bold-italic": "sans-serif-bold-italic",
+                               "sans-serif-bold": "sans-serif-bold-italic" },
+        "sans-serif-bold-italic": { normal: "sans-serif-bold-italic",
+                                    italic: "sans-serif-bold-italic",
+                                    "sans-serif": "sans-serif-bold-italic",
+                                    "sans-serif-italic": "sans-serif-bold-italic",
+                                    bold: "sans-serif-bold-italic",
+                                    "bold-italic": "sans-serif-bold-italic",
+                                    "sans-serif-bold": "sans-serif-bold-italic" },
+      }.freeze
+
+      def mathvariant_override(inner, outer)
+        o = outer.to_sym
+        i = inner.to_sym
+        MATHVARIANT_OVERRIDE[o] or return inner
+        MATHVARIANT_OVERRIDE[o][i] || inner
+      end
+
+      def mathml_mathvariant(math)
+        math.xpath(".//*[@mathvariant]").each do |outer|
+          outer.xpath(".//*[@mathvariant]").each do |inner|
+            inner["mathvariant"] =
+              mathvariant_override(inner["mathvariant"], outer["mathvariant"])
+          end
+        end
+        mathml_italicise(math)
+      end
+    end
+  end
+end

data/lib/metanorma/standoc/cleanup_terms.rb

@@ -73,11 +73,14 @@ module Metanorma
         xmldoc.xpath("//termdocsource").each { |s| f.previous = s.remove }
       end
 
-      def term_children_cleanup(xmldoc)
+      def terms_terms_cleanup(xmldoc)
         xmldoc.xpath("//terms[terms][not(term)]").each do |t|
           t.name = "clause"
           t["type"] = "terms"
         end
+      end
+
+      def term_children_cleanup(xmldoc)
         xmldoc.xpath("//term").each do |t|
           %w(termnote termexample termsource term).each do |w|
             t.xpath("./#{w}").each { |n| t << n.remove }

data/lib/metanorma/standoc/cleanup_terms_boilerplate.rb

@@ -0,0 +1,106 @@
+module Metanorma
+  module Standoc
+    module Cleanup
+      def external_terms_boilerplate(sources)
+        e = @i18n.external_terms_boilerplate
+        e.gsub(/%(?=\p{P}|\p{Z}|$)/, sources || "???")
+      end
+
+      def internal_external_terms_boilerplate(sources)
+        e = @i18n.internal_external_terms_boilerplate
+        e.gsub(/%(?=\p{P}|\p{Z}|$)/, sources || "??")
+      end
+
+      def boilerplate_snippet_convert(adoc)
+        ret = boilerplate_xml_cleanup(adoc2xml(adoc, backend.to_sym))
+        @i18n.l10n(ret.children.to_xml, @lang, @script)
+      end
+
+      def term_defs_boilerplate(div, source, term, _preface, isodoc)
+        verify_term_defs_source(source)
+        a = @i18n.term_def_boilerplate and
+          div.next = boilerplate_snippet_convert(a)
+        a = if source.empty? && term.nil? then @i18n.no_terms_boilerplate
+            else term_defs_boilerplate_cont(source, term, isodoc)
+            end
+        a and div.next = boilerplate_snippet_convert(a)
+      end
+
+      def verify_term_defs_source(source)
+        source.each do |s|
+          @anchors[s["bibitemid"]] or
+            @log.add("Crossreferences", nil,
+                     "term source #{s['bibitemid']} not referenced",
+                     severity: 1)
+        end
+      end
+
+      def term_defs_boilerplate_cont(src, term, isodoc)
+        sources = isodoc.sentence_join(src.map do |s|
+          %{<<#{s['bibitemid']}>>}
+        end)
+        if src.empty? then @i18n.internal_terms_boilerplate
+        elsif term.nil? then external_terms_boilerplate(sources)
+        else
+          internal_external_terms_boilerplate(sources)
+        end
+      end
+
+      TERM_CLAUSE =
+        "//sections//terms[not(.//ancestor::clause[@type = 'terms'])] | " \
+        "//sections/clause[descendant::terms][@type = 'terms'] | " \
+        "//sections/clause[not(@type = 'terms')]//terms".freeze
+
+      def termdef_boilerplate_cleanup(xmldoc)
+        # termdef_remove_initial_paras(xmldoc)
+      end
+
+      def termdef_remove_initial_paras(xmldoc)
+        xmldoc.xpath("//terms/p | //terms/ul").each(&:remove)
+      end
+
+      def termdef_boilerplate_insert(xmldoc, isodoc, once = false)
+        if once
+          f = termdef_boilerplate_insert_location(xmldoc) and
+            termdef_boilerplate_insert1(f, xmldoc, isodoc)
+        else
+          xmldoc.xpath(self.class::TERM_CLAUSE).each do |f|
+            termdef_boilerplate_insert1(f, xmldoc, isodoc)
+          end
+        end
+      end
+
+      def termdef_boilerplate_insert_location(xmldoc)
+        f = xmldoc.at(self.class::TERM_CLAUSE)
+        root = xmldoc.at("//sections/terms | //sections/clause[@type = 'terms']")
+        if f && root && f["id"] != root["id"]
+          f = termdef_boilerplate_climb_up(f, root)
+        elsif !f && root then f = root
+        end
+        f
+      end
+
+      def termdef_boilerplate_climb_up(clause, container)
+        container.at(".//*[@id = '#{clause['id']}']") or return clause
+        while (n = clause.parent)
+          n.at(".//definitions") and break
+          clause = n
+          n["id"] == container["id"] and break
+        end
+        clause
+      end
+
+      def termdef_boilerplate_insert1(sect, xmldoc, isodoc)
+        ins = sect.at("./title")
+        if (ins2 = sect.at("./clause[@type = 'boilerplate'] | " \
+                "./note[@type = 'boilerplate']"))
+          ins2.text.strip.downcase == "(default)" or return
+          ins2.children = " "
+          ins = ins2.children.first
+        end
+        term_defs_boilerplate(ins, xmldoc.xpath(".//termdocsource"),
+                              sect.at(".//term"), sect.at(".//p"), isodoc)
+      end
+    end
+  end
+end