metanorma-standoc 1.8.5 → 1.9.1

data/lib/asciidoctor/standoc/cleanup_block.rb

@@ -29,7 +29,7 @@ module Asciidoctor
       def dl2_table_cleanup(xmldoc)
         q = "//table/following-sibling::*[1][self::p]"
         xmldoc.xpath(q).each do |s|
-          if s.text =~ /^\s*key[^a-z]*$/i && !s.next_element.nil? && s.next_element.name == "dl"
+          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
@@ -40,6 +40,7 @@ module Asciidoctor
       def insert_thead(s)
         thead = s.at("./thead")
         return thead unless thead.nil?
+
         if tname = s.at("./name")
           thead = tname.add_next_sibling("<thead/>").first
           return thead
@@ -80,22 +81,22 @@ 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|
-          if s.text =~ /^\s*where[^a-z]*$/i && !s.next_element.nil? && s.next_element.name == "dl"
+        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
             s.remove
@@ -114,7 +115,7 @@ module Asciidoctor
       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.nil? && s.next_element.name == "dl"
+          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
@@ -125,7 +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 { |m| %w(name figure).include? m }.empty?
+          next unless e.elements.map(&:name).reject do |m|
+            %w(name figure).include? m
+          end.empty?
+
           e.name = "figure"
         end
       end
@@ -140,82 +144,75 @@ 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, it is moved inside its preceding block if it is not delimited
+      # 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)
         q = "//note[following-sibling::*[not(local-name() = 'note')]]"
         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
-        xmldoc.xpath("//note[@keep-separate]").each { |n| n.delete("keep-separate") }
-        xmldoc.xpath("//termnote[@keep-separate]").each { |n| n.delete("keep-separate") }
+        xmldoc.xpath("//note[@keep-separate] | "\
+                     "//termnote[@keep-separate]").each do |n|
+          n.delete("keep-separate")
+        end
       end
 
-      def requirement_cleanup(x)
-        requirement_descriptions(x)
-        requirement_inherit(x)
+      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_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 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_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
+      def merge_annotations_into_sourcecode(xmldoc)
+        xmldoc.xpath("//sourcecode").each do |x|
+          while x&.next_element&.name == "annotation"
+            x.next_element.parent = x
           end
-          requirement_cleanup1(r)
         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 { |d| d.replace("\n") }
+      def callout_cleanup(xmldoc)
+        merge_annotations_into_sourcecode(xmldoc)
+        align_callouts_to_annotations(xmldoc)
       end
 
-      def svgmap_cleanup(xmldoc)
-        svgmap_populate(xmldoc)
-        Metanorma::Utils::svgmap_rewrite(xmldoc, @localdir)
-      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_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()")
-            next if href.empty?
-            s << %[<target href="#{svgmap_target(href)}">#{t.to_xml}</target>]
+            n.replace(sourcecode_markup(n))
           end
         end
       end
 
-      def svgmap_target(nodeset)
-        nodeset.each do |n|
-          next unless n.name == "link"
-          n.children = n["target"]
+      def sourcecode_markup(n)
+        acc = []
+        n.text.split(/(#{Regexp.escape(@sourcecode_markup_start)}|#{Regexp.escape(@sourcecode_markup_end)})/)
+          .each_slice(4).map do |a|
+          acc << Nokogiri::XML::Text.new(a[0], n.document)
+            .to_xml(encoding: "US-ASCII", save_with: Nokogiri::XML::Node::SaveOptions::NO_DECLARATION)
+          next unless a.size == 4
+
+          acc << Asciidoctor.convert(a[2], backend: (self&.backend&.to_sym || :standoc), doctype: :inline)
         end
-        nodeset.text.sub(/^[,; ]/, "").strip
+        acc.join
       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,19 @@ 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)
+        refs = ref.elements.select do |e|
+          %w(references bibitem).include? e.name
         end
-        f.at("./title").next =
-          "<p>#{(refs.empty? ? @i18n.norm_empty_pref : @i18n.norm_with_refs_pref)}</p>"
+        pref = refs.empty? ? @i18n.norm_empty_pref : @i18n.norm_with_refs_pref
+        ref.at("./title").next = "<p>#{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,7 +62,7 @@ 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)
@@ -76,6 +83,7 @@ module Asciidoctor
         termdef_boilerplate_cleanup(xmldoc)
         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"),
                                 f.at(".//term"), f.at(".//p"), isodoc)
         end
@@ -84,15 +92,16 @@ module Asciidoctor
         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 +109,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 +127,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

data/lib/asciidoctor/standoc/cleanup_maths.rb

@@ -3,36 +3,39 @@ require "pathname"
 require "open-uri"
 require "html2doc"
 require "asciimath2unitsml"
-require_relative "./cleanup_block.rb"
-require_relative "./cleanup_footnotes.rb"
-require_relative "./cleanup_ref.rb"
-require_relative "./cleanup_ref_dl.rb"
-require_relative "./cleanup_boilerplate.rb"
-require_relative "./cleanup_section.rb"
-require_relative "./cleanup_terms.rb"
-require_relative "./cleanup_inline.rb"
-require_relative "./cleanup_amend.rb"
+require_relative "./cleanup_block"
+require_relative "./cleanup_footnotes"
+require_relative "./cleanup_ref"
+require_relative "./cleanup_ref_dl"
+require_relative "./cleanup_boilerplate"
+require_relative "./cleanup_section"
+require_relative "./cleanup_terms"
+require_relative "./cleanup_inline"
+require_relative "./cleanup_amend"
 require "relaton_iev"
 
 module Asciidoctor
   module Standoc
     module Cleanup
       def asciimath2mathml(text)
-        text = text.gsub(%r{<stem type="AsciiMath">(.+?)</stem>}m) do |m|
-            "<amathstem>#{HTMLEntities.new.decode($1)}</amathstem>"
-          end
-          text = Html2Doc.asciimath_to_mathml(text, ["<amathstem>", "</amathstem>"])
-          x =  Nokogiri::XML(text)
-          x.xpath("//*[local-name() = 'math'][not(parent::stem)]").each do |y|
-            y.wrap("<stem type='MathML'></stem>")
-          end
-          x.to_xml
+        text = text.gsub(%r{<stem type="AsciiMath">(.+?)</stem>}m) do
+          "<amathstem>#{HTMLEntities.new.decode($1)}</amathstem>"
+        end
+        text = Html2Doc.asciimath_to_mathml(text,
+                                            ["<amathstem>", "</amathstem>"])
+        x =  Nokogiri::XML(text)
+        x.xpath("//*[local-name() = 'math'][not(parent::stem)]").each do |y|
+          y.wrap("<stem type='MathML'></stem>")
+        end
+        x.to_xml
       end
 
       def xml_unescape_mathml(x)
         return if x.children.any? { |y| y.element? }
-        math = x.text.gsub(/&lt;/, "<").gsub(/&gt;/, ">").gsub(/&quot;/, '"').gsub(/&apos;/, "'").gsub(/&amp;/, "&").
-          gsub(/<[^: \r\n\t\/]+:/, "<").gsub(/<\/[^ \r\n\t:]+:/, "</")
+
+        math = x.text.gsub(/&lt;/, "<").gsub(/&gt;/, ">")
+          .gsub(/&quot;/, '"').gsub(/&apos;/, "'").gsub(/&amp;/, "&")
+          .gsub(/<[^: \r\n\t\/]+:/, "<").gsub(/<\/[^ \r\n\t:]+:/, "</")
         x.children = math
       end
 
@@ -40,12 +43,13 @@ module Asciidoctor
 
       def mathml_preserve_space(m)
         m.xpath(".//m:mtext", "m" => MATHML_NS).each do |x|
-          x.children = x.children.to_xml.gsub(/^\s/, "&#xA0;").gsub(/\s$/, "&#xA0;")
+          x.children = x.children.to_xml
+            .gsub(/^\s/, "&#xA0;").gsub(/\s$/, "&#xA0;")
         end
       end
 
       def mathml_namespace(stem)
-        stem.xpath("./math", ).each { |x| x.default_namespace = MATHML_NS }
+        stem.xpath("./math").each { |x| x.default_namespace = MATHML_NS }
       end
 
       def mathml_mi_italics
@@ -55,7 +59,8 @@ module Asciidoctor
 
       # presuppose multichar mi upright, singlechar mi MathML default italic
       def mathml_italicise(x)
-        x.xpath(".//m:mi[not(ancestor::*[@mathvariant])]", "m" => MATHML_NS).each do |i|
+        x.xpath(".//m:mi[not(ancestor::*[@mathvariant])]",
+                "m" => MATHML_NS).each do |i|
           char = HTMLEntities.new.decode(i.text)
           i["mathvariant"] = "normal" if mi_italicise?(char)
         end
@@ -63,10 +68,11 @@ module Asciidoctor
 
       def mi_italicise?(c)
         return false if c.length > 1
-        if /\p{Greek}/.match(c)
+
+        if /\p{Greek}/.match?(c)
           /\p{Lower}/.match(c) && !mathml_mi_italics[:lowergreek] ||
             /\p{Upper}/.match(c) && !mathml_mi_italics[:uppergreek]
-        elsif /\p{Latin}/.match(c)
+        elsif /\p{Latin}/.match?(c)
           /\p{Lower}/.match(c) && !mathml_mi_italics[:lowerroman] ||
             /\p{Upper}/.match(c) && !mathml_mi_italics[:upperroman]
         else
@@ -74,7 +80,7 @@ module Asciidoctor
         end
       end
 
-      UNITSML_NS = "http://unitsml.nist.gov/2005".freeze
+      UNITSML_NS = "https://schema.unitsml.org/unitsml/1.0".freeze
 
       def add_misc_container(xmldoc)
         unless ins = xmldoc.at("//misc-container")
@@ -87,6 +93,7 @@ module Asciidoctor
 
       def mathml_unitsML(xmldoc)
         return unless xmldoc.at(".//m:*", "m" => UNITSML_NS)
+
         misc = add_misc_container(xmldoc)
         unitsml = misc.add_child("<UnitsML xmlns='#{UNITSML_NS}'/>").first
         %w(Unit CountedItem Quantity Dimension Prefix).each do |t|
@@ -95,12 +102,14 @@ module Asciidoctor
       end
 
       def gather_unitsml(unitsml, xmldoc, t)
-        tags = xmldoc.xpath(".//m:#{t}", "m" => UNITSML_NS).each_with_object({}) do |x, m|
+        tags = xmldoc.xpath(".//m:#{t}", "m" => UNITSML_NS)
+          .each_with_object({}) do |x, m|
           m[x["id"]] = x.remove
         end
         return if tags.empty?
+
         set = unitsml.add_child("<#{t}Set/>").first
-        tags.values.each { |v| set << v }
+        tags.each_value { |v| set << v }
       end
 
       def asciimath2unitsml_options