metanorma-standoc 1.8.8 → 1.9.4

data/lib/asciidoctor/standoc/cleanup_block.rb

@@ -37,14 +37,15 @@ module Asciidoctor
         end
       end
 
-      def insert_thead(s)
-        thead = s.at("./thead")
+      def insert_thead(table)
+        thead = table.at("./thead")
         return thead unless thead.nil?
-        if tname = s.at("./name")
+
+        if tname = table.at("./name")
           thead = tname.add_next_sibling("<thead/>").first
           return thead
         end
-        s.children.first.add_previous_sibling("<thead/>").first
+        table.children.first.add_previous_sibling("<thead/>").first
       end
 
       def header_rows_cleanup(xmldoc)
@@ -80,21 +81,21 @@ module Asciidoctor
       end
 
       # include where definition list inside stem block
-      def formula_cleanup(x)
-        formula_cleanup_where1(x)
-        formula_cleanup_where2(x)
+      def formula_cleanup(formula)
+        formula_cleanup_where1(formula)
+        formula_cleanup_where2(formula)
       end
 
-      def formula_cleanup_where1(x)
+      def formula_cleanup_where1(formula)
         q = "//formula/following-sibling::*[1][self::dl]"
-        x.xpath(q).each do |s|
+        formula.xpath(q).each do |s|
           s["key"] == "true" and s.previous_element << s.remove
         end
       end
 
-      def formula_cleanup_where2(x)
+      def formula_cleanup_where2(formula)
         q = "//formula/following-sibling::*[1][self::p]"
-        x.xpath(q).each do |s|
+        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
@@ -125,9 +126,10 @@ module Asciidoctor
       # examples containing only figures become subfigures of figures
       def subfigure_cleanup(xmldoc)
         xmldoc.xpath("//example[figure]").each do |e|
-          next unless e.elements.map { |m| m.name }.reject do |m|
+          next unless e.elements.map(&:name).reject do |m|
             %w(name figure).include? m
           end.empty?
+
           e.name = "figure"
         end
       end
@@ -142,7 +144,7 @@ module Asciidoctor
       ELEMS_ALLOW_NOTES = %w[p formula ul ol dl figure].freeze
 
       # if a note is at the end of a section, it is left alone
-      # if a note is followed by a non-note block, 
+      # if a note is followed by a non-note block,
       # it is moved inside its preceding block if it is not delimited
       # (so there was no way of making that block include the note)
       def note_cleanup(xmldoc)
@@ -150,6 +152,7 @@ module Asciidoctor
         xmldoc.xpath(q).each do |n|
           next if n["keep-separate"] == "true"
           next unless n.ancestors("table").empty?
+
           prev = n.previous_element || next
           n.parent = prev if ELEMS_ALLOW_NOTES.include? prev.name
         end
@@ -159,100 +162,75 @@ module Asciidoctor
         end
       end
 
-      def requirement_cleanup(x)
-        requirement_descriptions(x)
-        requirement_inherit(x)
-      end
-
-      def requirement_inherit(x)
-        x.xpath("//requirement | //recommendation | //permission").each do |r|
-          ins = r.at("./classification") ||
-            r.at("./description | ./measurementtarget | ./specification | "\
-                 "./verification | ./import | ./description | ./requirement | "\
-                 "./recommendation | ./permission")
-          r.xpath("./*//inherit").each { |i| ins.previous = i }
+      def link_callouts_to_annotations(callouts, annotations)
+        callouts.each_with_index do |c, i|
+          c["target"] = "_#{UUIDTools::UUID.random_create}"
+          annotations[i]["id"] = c["target"]
         end
       end
 
-      def requirement_descriptions(x)
-        x.xpath("//requirement | //recommendation | //permission").each do |r|
-          r.children.each do |e|
-            unless e.element? && (reqt_subpart(e.name) ||
-                %w(requirement recommendation permission).include?(e.name))
-              t = Nokogiri::XML::Element.new("description", x)
-              e.before(t)
-              t.children = e.remove
-            end
-          end
-          requirement_cleanup1(r)
+      def align_callouts_to_annotations(xmldoc)
+        xmldoc.xpath("//sourcecode").each do |x|
+          callouts = x.elements.select { |e| e.name == "callout" }
+          annotations = x.elements.select { |e| e.name == "annotation" }
+          callouts.size == annotations.size and
+            link_callouts_to_annotations(callouts, annotations)
         end
       end
 
-      def requirement_cleanup1(r)
-        while d = r.at("./description[following-sibling::*[1]"\
-            "[self::description]]")
-          n = d.next.remove
-          d << n.children
-        end
-        r.xpath("./description[normalize-space(.)='']").each do |d|
-          d.replace("\n")
+      def merge_annotations_into_sourcecode(xmldoc)
+        xmldoc.xpath("//sourcecode").each do |x|
+          while x&.next_element&.name == "annotation"
+            x.next_element.parent = x
+          end
         end
       end
 
-      def svgmap_cleanup(xmldoc)
-        svgmap_moveattrs(xmldoc)
-        svgmap_populate(xmldoc)
-        Metanorma::Utils::svgmap_rewrite(xmldoc, @localdir)
+      def callout_cleanup(xmldoc)
+        merge_annotations_into_sourcecode(xmldoc)
+        align_callouts_to_annotations(xmldoc)
       end
 
-      def guid?(x)
-        /^_[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i.
-          match(x)
-      end
+      def sourcecode_cleanup(xmldoc)
+        xmldoc.xpath("//sourcecode").each do |x|
+          x.traverse do |n|
+            next unless n.text?
+            next unless /#{Regexp.escape(@sourcecode_markup_start)}/
+              .match?(n.text)
 
-      def svgmap_moveattrs(xmldoc)
-        xmldoc.xpath("//svgmap").each do |s|
-          f = s.at(".//figure") or next
-          if t = s.at("./name") and !f.at("./name")
-            f.children.first.previous = t.remove
+            n.replace(sourcecode_markup(n))
           end
-          if s["id"] && guid?(f["id"])
-            f["id"] = s["id"]
-            s.delete("id")
-          end
-          svgmap_moveattrs1(s, f)
         end
       end
 
-      def svgmap_moveattrs1(s, f)
-        %w(unnumbered number subsequence keep-with-next
-          keep-lines-together).each do |a|
-            next if f[a] || !s[a]
-            f[a] = s[a]
-            s.delete(a)
-          end
+      def safe_noko(text, doc)
+        Nokogiri::XML::Text.new(text, doc).to_xml(
+          encoding: "US-ASCII",
+          save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION
+        )
       end
 
-      def svgmap_populate(xmldoc)
-        xmldoc.xpath("//svgmap").each do |s|
-          s1 = s.dup
-          s.children.remove
-          f = s1.at(".//figure") and s << f
-          s1.xpath(".//li").each do |li|
-            t = li&.at(".//eref | .//link | .//xref") or next
-            href = t.xpath("./following-sibling::node()")
-            href.empty? or
-              s << %[<target href="#{svgmap_target(href)}">#{t.to_xml}</target>]
-          end
+      def sourcecode_markup(node)
+        acc = []
+        node.text.split(/(#{Regexp.escape(@sourcecode_markup_start)}|
+                          #{Regexp.escape(@sourcecode_markup_end)})/x)
+          .each_slice(4).map do |a|
+          acc << safe_noko(a[0], node.document)
+          next unless a.size == 4
+
+          acc << Asciidoctor.convert(
+            a[2], doctype: :inline, backend: (self&.backend&.to_sym || :standoc)
+          )
         end
+        acc.join
       end
 
-      def svgmap_target(nodeset)
-        nodeset.each do |n|
-          next unless n.name == "link"
-          n.children = n["target"]
+      def form_cleanup(xmldoc)
+        xmldoc.xpath("//select").each do |s|
+          while s&.next_element&.name == "option"
+            s << s.next_element
+          end
         end
-        nodeset.text.sub(/^[,; ]/, "").strip
       end
     end
   end

data/lib/asciidoctor/standoc/cleanup_boilerplate.rb

@@ -3,21 +3,26 @@ module Asciidoctor
     module Cleanup
       def external_terms_boilerplate(sources)
         @i18n.l10n(
-          @i18n.external_terms_boilerplate.gsub(/%/, sources || "???"), @lang, @script)
+          @i18n.external_terms_boilerplate.gsub(/%/, sources || "???"),
+          @lang, @script
+        )
       end
 
       def internal_external_terms_boilerplate(sources)
         @i18n.l10n(
-          @i18n.internal_external_terms_boilerplate.gsub(/%/, sources || "??"), @lang, @script)
+          @i18n.internal_external_terms_boilerplate.gsub(/%/, 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")
+            @log.add("Crossreferences", nil,
+                     "term source #{s['bibitemid']} not referenced")
         end
-        a = (source.empty? && term.nil?) ?  @i18n.no_terms_boilerplate :
+        a = source.empty? && term.nil? ?  @i18n.no_terms_boilerplate :
           term_defs_boilerplate_cont(source, term, isodoc)
         a and div.next = a
       end
@@ -33,17 +38,23 @@ module Asciidoctor
         end
       end
 
-      def norm_ref_preface(f)
-        refs = f.elements.select do |e|
-          ["reference", "bibitem"].include? e.name
+      def norm_ref_preface(ref)
+        if ref.at("./note[@type = 'boilerplate']")
+          unwrap_boilerplate_clauses(ref, ".")
+        else
+          refs = ref.elements.select do |e|
+            %w(references bibitem).include? e.name
+          end
+          pref = refs.empty? ? @i18n.norm_empty_pref : @i18n.norm_with_refs_pref
+          ref.at("./title").next = "<p>#{pref}</p>"
         end
-        f.at("./title").next =
-          "<p>#{(refs.empty? ? @i18n.norm_empty_pref : @i18n.norm_with_refs_pref)}</p>"
       end
 
-      TERM_CLAUSE = "//sections/terms | //sections/clause[descendant::terms]".freeze
+      TERM_CLAUSE = "//sections/terms | "\
+        "//sections/clause[descendant::terms]".freeze
 
-      NORM_REF = "//bibliography/references[@normative = 'true']".freeze
+      NORM_REF = "//bibliography/references[@normative = 'true'] | "\
+        "//bibliography/clause[.//references[@normative = 'true']]".freeze
 
       def boilerplate_isodoc(xmldoc)
         x = xmldoc.dup
@@ -55,44 +66,53 @@ module Asciidoctor
       end
 
       def termdef_boilerplate_cleanup(xmldoc)
-        #termdef_remove_initial_paras(xmldoc)
+        # termdef_remove_initial_paras(xmldoc)
       end
 
       def termdef_remove_initial_paras(xmldoc)
         xmldoc.xpath("//terms/p | //terms/ul").each(&:remove)
       end
 
-      def termdef_unwrap_boilerplate_clauses(xmldoc)
-        xmldoc.xpath(self.class::TERM_CLAUSE).each do |f|
-          f.xpath(".//clause[@type = 'boilerplate']").each do |c|
+      def unwrap_boilerplate_clauses(xmldoc, xpath)
+        xmldoc.xpath(xpath).each do |f|
+          f.xpath(".//clause[@type = 'boilerplate'] | "\
+                  ".//note[@type = 'boilerplate']").each do |c|
             c&.at("./title")&.remove
             c.replace(c.children)
           end
         end
       end
 
-      def boilerplate_cleanup(xmldoc)
-        isodoc = boilerplate_isodoc(xmldoc)
-        termdef_boilerplate_cleanup(xmldoc)
+      def termdef_boilerplate_insert(xmldoc, isodoc, once = false)
         xmldoc.xpath(self.class::TERM_CLAUSE).each do |f|
           next if f.at("./clause[@type = 'boilerplate']")
-          term_defs_boilerplate(f.at("./title"), xmldoc.xpath(".//termdocsource"),
+
+          term_defs_boilerplate(f.at("./title"),
+                                xmldoc.xpath(".//termdocsource"),
                                 f.at(".//term"), f.at(".//p"), isodoc)
+          break if once
         end
-        termdef_unwrap_boilerplate_clauses(xmldoc)
+      end
+
+      def boilerplate_cleanup(xmldoc)
+        isodoc = boilerplate_isodoc(xmldoc)
+        termdef_boilerplate_cleanup(xmldoc)
+        termdef_boilerplate_insert(xmldoc, isodoc)
+        unwrap_boilerplate_clauses(xmldoc, self.class::TERM_CLAUSE)
         f = xmldoc.at(self.class::NORM_REF) and norm_ref_preface(f)
         initial_boilerplate(xmldoc, isodoc)
       end
 
-      def initial_boilerplate(x, isodoc)
-        return if x.at("//boilerplate")
-        preface = x.at("//preface") || x.at("//sections") || x.at("//annex") ||
-          x.at("//references") || return
-        b = boilerplate(x, isodoc) or return
+      def initial_boilerplate(xml, isodoc)
+        return if xml.at("//boilerplate")
+
+        preface = xml.at("//preface") || xml.at("//sections") ||
+          xml.at("//annex") || xml.at("//references") || return
+        b = boilerplate(xml, isodoc) or return
         preface.previous = b
       end
 
-      def boilerplate_file(xmldoc)
+      def boilerplate_file(_xmldoc)
         File.join(@libdir, "boilerplate.xml")
       end
 
@@ -100,7 +120,7 @@ module Asciidoctor
         file = boilerplate_file(xml)
         file = File.join(@localdir, @boilerplateauthority) if @boilerplateauthority
         !file.nil? and File.exists?(file) or return
-        conv.populate_template((File.read(file, encoding: "UTF-8")), nil)
+        conv.populate_template(File.read(file, encoding: "UTF-8"), nil)
       end
 
       def bibdata_cleanup(xmldoc)
@@ -118,14 +138,16 @@ module Asciidoctor
       def bibdata_docidentifier_cleanup(xmldoc)
         ins = xmldoc.at("//bibdata/docidentifier")
         xmldoc.xpath("//bibdata/docidentifier").each_with_index do |b, i|
-          next if i == 0
+          next if i.zero?
+
           ins.next = b.remove
           ins = ins.next
         end
       end
 
       def gather_indirect_erefs(xmldoc, prefix)
-        xmldoc.xpath("//eref[@type = '#{prefix}']").each_with_object({}) do |e, m|
+        xmldoc.xpath("//eref[@type = '#{prefix}']")
+          .each_with_object({}) do |e, m|
           e.delete("type")
           m[e["bibitemid"]] = true
         end.keys

data/lib/asciidoctor/standoc/cleanup_footnotes.rb

@@ -20,6 +20,7 @@ module Asciidoctor
           nomatches = true
           xmldoc.xpath(q).each do |s|
             next if s.children.map { |c| c.text? && /[[:alpha:]]/.match(c.text) }.any?
+
             s.previous_element << s.first_element_child.remove
             s.remove
             nomatches = false

data/lib/asciidoctor/standoc/cleanup_image.rb

@@ -0,0 +1,71 @@
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def svgmap_cleanup(xmldoc)
+        svgmap_moveattrs(xmldoc)
+        svgmap_populate(xmldoc)
+        Metanorma::Utils::svgmap_rewrite(xmldoc, @localdir)
+      end
+
+      def guid?(str)
+        /^_[0-9A-F]{8}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{4}-[0-9A-F]{12}$/i
+          .match(str)
+      end
+
+      def svgmap_moveattrs(xmldoc)
+        xmldoc.xpath("//svgmap").each do |s|
+          f = s.at(".//figure") or next
+          if (t = s.at("./name")) && !f.at("./name")
+            f.children.first.previous = t.remove
+          end
+          if s["id"] && guid?(f["id"])
+            f["id"] = s["id"]
+            s.delete("id")
+          end
+          svgmap_moveattrs1(s, f)
+        end
+      end
+
+      def svgmap_moveattrs1(s, f)
+        %w(unnumbered number subsequence keep-with-next
+           keep-lines-together).each do |a|
+          next if f[a] || !s[a]
+
+          f[a] = s[a]
+          s.delete(a)
+        end
+      end
+
+      def svgmap_populate(xmldoc)
+        xmldoc.xpath("//svgmap").each do |s|
+          s1 = s.dup
+          s.children.remove
+          f = s1.at(".//figure") and s << f
+          s1.xpath(".//li").each do |li|
+            t = li&.at(".//eref | .//link | .//xref") or next
+            href = t.xpath("./following-sibling::node()")
+            href.empty? or
+              s << %[<target href="#{svgmap_target(href)}">#{t.to_xml}</target>]
+          end
+        end
+      end
+
+      def svgmap_target(nodeset)
+        nodeset.each do |n|
+          next unless n.name == "link"
+
+          n.children = n["target"]
+        end
+        nodeset.text.sub(/^[,; ]/, "").strip
+      end
+
+      def img_cleanup(xmldoc)
+        return xmldoc unless @datauriimage
+
+        xmldoc.xpath("//image").each do |i|
+          i["src"] = Metanorma::Utils::datauri(i["src"], @localdir)
+        end
+      end
+    end
+  end
+end