metanorma-standoc 1.10.4.1 → 1.10.8

data/lib/asciidoctor/standoc/cleanup_image.rb

@@ -15,9 +15,8 @@ module Asciidoctor
       def svgmap_moveattrs(xmldoc)
         xmldoc.xpath("//svgmap").each do |s|
           f = s.at(".//figure") or next
-          if (t = s.at("./name")) && !f.at("./name")
+          (t = s.at("./name")) && !f.at("./name") and
             f.children.first.previous = t.remove
-          end
           if s["id"] && guid?(f["id"])
             f["id"] = s["id"]
             s.delete("id")
@@ -26,13 +25,13 @@ module Asciidoctor
         end
       end
 
-      def svgmap_moveattrs1(s, f)
+      def svgmap_moveattrs1(svgmap, figure)
         %w(unnumbered number subsequence keep-with-next
-           keep-lines-together).each do |a|
-          next if f[a] || !s[a]
+           keep-lines-together tag multilingual-rendering).each do |a|
+          next if figure[a] || !svgmap[a]
 
-          f[a] = s[a]
-          s.delete(a)
+          figure[a] = svgmap[a]
+          svgmap.delete(a)
         end
       end
 

data/lib/asciidoctor/standoc/cleanup_inline.rb

@@ -1,4 +1,5 @@
 require "metanorma-utils"
+require "digest"
 
 module Asciidoctor
   module Standoc
@@ -55,103 +56,6 @@ module Asciidoctor
         end
       end
 
-      # extending localities to cover ISO referencing
-      LOCALITY_REGEX_STR = <<~REGEXP.freeze
-        ^((?<locality>section|clause|part|paragraph|chapter|page|
-                      table|annex|figure|example|note|formula|list|time|anchor|
-                      locality:[^ \\t\\n\\r:,;=]+)(\\s+|=)
-               (?<ref>[^"][^ \\t\\n,:-]*|"[^"]+")
-                 (-(?<to>[^"][^ \\t\\n,:-]*|"[^"]"))?|
-          (?<locality2>whole|locality:[^ \\t\\n\\r:,;=]+))(?<punct>[,:;]?)\\s*
-         (?<text>.*)$
-      REGEXP
-      LOCALITY_RE = Regexp.new(LOCALITY_REGEX_STR.gsub(/\s/, ""),
-                               Regexp::IGNORECASE | Regexp::MULTILINE)
-
-      def tq(text)
-        text.sub(/^"/, "").sub(/"$/, "")
-      end
-
-      def extract_localities(elem)
-        f = elem&.children&.first or return
-        f.text? or return
-        head = f.remove.text
-        tail = elem&.children&.remove
-        extract_localities1(elem, head)
-        tail and elem << tail
-      end
-
-      def extract_localities1(elem, text)
-        b = elem.add_child("<localityStack/>").first if LOCALITY_RE.match text
-        while (m = LOCALITY_RE.match text)
-          ref = m[:ref] ? "<referenceFrom>#{tq m[:ref]}</referenceFrom>" : ""
-          refto = m[:to] ? "<referenceTo>#{tq m[:to]}</referenceTo>" : ""
-          loc = m[:locality]&.downcase || m[:locality2]&.downcase
-          b.add_child("<locality type='#{loc}'>#{ref}#{refto}</locality>")
-          text = m[:text]
-          b = elem.add_child("<localityStack/>").first if m[:punct] == ";"
-        end
-        elem.add_child(text) if text
-      end
-
-      def xref_to_eref(elem)
-        elem["bibitemid"] = elem["target"]
-        unless elem["citeas"] = @anchors&.dig(elem["target"], :xref)
-          @internal_eref_namespaces.include?(elem["type"]) or
-            @log.add("Crossreferences", elem,
-                     "#{elem['target']} does not have a corresponding "\
-                     "anchor ID in the bibliography!")
-        end
-        elem.delete("target")
-        extract_localities(elem) unless elem.children.empty?
-      end
-
-      def xref_cleanup(xmldoc)
-        xmldoc.xpath("//xref").each do |x|
-          /:/.match(x["target"]) and xref_to_internal_eref(x)
-          next unless x.name == "xref"
-
-          if refid? x["target"]
-            x.name = "eref"
-            xref_to_eref(x)
-          else x.delete("type")
-          end
-        end
-      end
-
-      def xref_to_internal_eref(elem)
-        a = elem["target"].split(":", 3)
-        unless a.size < 2 || a[0].empty? || a[1].empty?
-          elem["target"] = "#{a[0]}_#{a[1]}"
-          a.size > 2 and
-            elem.children = %{anchor="#{a[2..-1].join}",#{elem&.children&.text}}
-          elem["type"] = a[0]
-          @internal_eref_namespaces << a[0]
-          elem.name = "eref"
-          xref_to_eref(elem)
-        end
-      end
-
-      def quotesource_cleanup(xmldoc)
-        xmldoc.xpath("//quote/source | //terms/source").each do |x|
-          xref_to_eref(x)
-        end
-      end
-
-      def origin_cleanup(xmldoc)
-        xmldoc.xpath("//origin/concept[termref]").each do |x|
-          t = x.at("./termref")
-          x.replace(t)
-        end
-        xmldoc.xpath("//origin").each do |x|
-          x["citeas"] = @anchors&.dig(x["bibitemid"], :xref) or
-            @log.add("Crossreferences", x,
-                     "#{x['bibitemid']} does not have a corresponding anchor "\
-                     "ID in the bibliography!")
-          extract_localities(x) unless x.children.empty?
-        end
-      end
-
       def concept_cleanup(xmldoc)
         xmldoc.xpath("//concept[not(termxref)]").each do |x|
           term = x.at("./refterm")
@@ -203,11 +107,13 @@ module Asciidoctor
       end
 
       IDREF = "//*/@id | //review/@from | //review/@to | "\
-        "//callout/@target | //citation/@bibitemid | //eref/@bibitemid".freeze
+              "//callout/@target | //citation/@bibitemid | "\
+              "//eref/@bibitemid".freeze
 
       def anchor_cleanup(elem)
         anchor_cleanup1(elem)
         xreftarget_cleanup(elem)
+        contenthash_id_cleanup(elem)
       end
 
       def anchor_cleanup1(elem)
@@ -233,6 +139,29 @@ module Asciidoctor
           end
         end
       end
+
+      def guid?(str)
+        /^_[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/
+          .match?(str)
+      end
+
+      def contenthash_id_cleanup(doc)
+        ids = doc.xpath("//*[@id]").each_with_object({}) do |x, m|
+          next unless guid?(x["id"])
+
+          m[x["id"]] = contenthash(x)
+          x["id"] = m[x["id"]]
+        end
+        [%w(review from), %(review to), %(callout target), %(eref bibitemid),
+         %(citation bibitemid), %(xref target), %(xref to)].each do |a|
+          doc.xpath("//#{a[0]}").each { |x| ids[a[1]] and x[a[1]] = ids[a[1]] }
+        end
+      end
+
+      def contenthash(elem)
+        Digest::MD5.hexdigest("#{elem.path}////#{elem.text}")
+          .sub(/^(.{8})(.{4})(.{4})(.{4})(.{12})$/, "_\\1-\\2-\\3-\\4-\\5")
+      end
     end
   end
 end

data/lib/asciidoctor/standoc/cleanup_maths.rb

@@ -29,19 +29,19 @@ module Asciidoctor
         x.to_xml
       end
 
-      def xml_unescape_mathml(x)
-        return if x.children.any? { |y| y.element? }
+      def xml_unescape_mathml(xml)
+        return if xml.children.any? { |y| y.element? }
 
-        math = x.text.gsub(/&lt;/, "<").gsub(/&gt;/, ">")
+        math = xml.text.gsub(/&lt;/, "<").gsub(/&gt;/, ">")
           .gsub(/&quot;/, '"').gsub(/&apos;/, "'").gsub(/&amp;/, "&")
           .gsub(/<[^: \r\n\t\/]+:/, "<").gsub(/<\/[^ \r\n\t:]+:/, "</")
-        x.children = math
+        xml.children = math
       end
 
       MATHML_NS = "http://www.w3.org/1998/Math/MathML".freeze
 
-      def mathml_preserve_space(m)
-        m.xpath(".//m:mtext", "m" => MATHML_NS).each do |x|
+      def mathml_preserve_space(math)
+        math.xpath(".//m:mtext", "m" => MATHML_NS).each do |x|
           x.children = x.children.to_xml
             .gsub(/^\s/, "&#xA0;").gsub(/\s$/, "&#xA0;")
         end
@@ -57,23 +57,23 @@ module Asciidoctor
       end
 
       # 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|
+      def mathml_italicise(xml)
+        xml.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
       end
 
-      def mi_italicise?(c)
-        return false if c.length > 1
+      def mi_italicise?(char)
+        return false if char.length > 1
 
-        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)
-          /\p{Lower}/.match(c) && !mathml_mi_italics[:lowerroman] ||
-            /\p{Upper}/.match(c) && !mathml_mi_italics[:upperroman]
+        if /\p{Greek}/.match?(char)
+          /\p{Lower}/.match(char) && !mathml_mi_italics[:lowergreek] ||
+            /\p{Upper}/.match(char) && !mathml_mi_italics[:uppergreek]
+        elsif /\p{Latin}/.match?(char)
+          /\p{Lower}/.match(char) && !mathml_mi_italics[:lowerroman] ||
+            /\p{Upper}/.match(char) && !mathml_mi_italics[:upperroman]
         else
           false
         end
@@ -100,14 +100,14 @@ module Asciidoctor
         end
       end
 
-      def gather_unitsml(unitsml, xmldoc, t)
-        tags = xmldoc.xpath(".//m:#{t}", "m" => UNITSML_NS)
+      def gather_unitsml(unitsml, xmldoc, tag)
+        tags = xmldoc.xpath(".//m:#{tag}", "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
+        set = unitsml.add_child("<#{tag}Set/>").first
         tags.each_value { |v| set << v }
       end
 
@@ -115,14 +115,106 @@ module Asciidoctor
         { multiplier: :space }
       end
 
+      def mathvariant_override(inner, outer)
+        case outer
+        when "bold"
+          case inner
+          when "normal" then "bold"
+          when "italic" then "bold-italic"
+          when "fraktur" then "bold-fraktur"
+          when "script" then "bold-script"
+          when "sans-serif" then "bold-sans-serif"
+          when "sans-serif-italic" then "sans-serif-bold-italic"
+          else inner
+          end
+        when "italic"
+          case inner
+          when "normal" then "italic"
+          when "bold" then "bold-italic"
+          when "sans-serif" then "sans-serif-italic"
+          when "bold-sans-serif" then "sans-serif-bold-italic"
+          else inner
+          end
+        when "bold-italic"
+          case inner
+          when "normal", "bold", "italic" then "bold-italic"
+          when "sans-serif", "bold-sans-serif", "sans-serif-italic"
+            "sans-serif-bold-italic"
+          else inner
+          end
+        when "fraktur"
+          case inner
+          when "normal" then "fraktur"
+          when "bold" then "bold-fraktur"
+          else inner
+          end
+        when "bold-fraktur"
+          case inner
+          when "normal", "fraktur" then "bold-fraktur"
+          else inner
+          end
+        when "script"
+          case inner
+          when "normal" then "script"
+          when "bold" then "bold-script"
+          else inner
+          end
+        when "bold-script"
+          case inner
+          when "normal", "script" then "bold-script"
+          else inner
+          end
+        when "sans-serif"
+          case inner
+          when "normal" then "sans-serif"
+          when "bold" then "bold-sans-serif"
+          when "italic" then "sans-serif-italic"
+          when "bold-italic" then "sans-serif-bold-italic"
+          else inner
+          end
+        when "bold-sans-serif"
+          case inner
+          when "normal", "bold", "sans-serif" then "bold-sans-serif"
+          when "italic", "bold-italic", "sans-serif-italic"
+            "sans-serif-bold-italic"
+          else inner
+          end
+        when "sans-serif-italic"
+          case inner
+          when "normal", "italic", "sans-serif" then "sans-serif-italic"
+          when "bold", "bold-italic", "sans-serif-bold"
+            "sans-serif-bold-italic"
+          else inner
+          end
+        when "sans-serif-bold-italic"
+          case inner
+          when "normal", "italic", "sans-serif", "sans-serif-italic",
+          "bold", "bold-italic", "sans-serif-bold"
+            "sans-serif-bold-italic"
+          else inner
+          end
+        else inner
+        end
+      end
+
+      def mathml_mathvariant(math)
+        math.xpath(".//*[@mathvariant]").each do |outer|
+          outer.xpath(".//*[@mathvariant]").each do |inner|
+            inner["mathvariant"] =
+              mathvariant_override(outer["mathvariant"], inner["mathvariant"])
+          end
+        end
+      end
+
       def mathml_cleanup(xmldoc)
         unitsml = Asciimath2UnitsML::Conv.new(asciimath2unitsml_options)
         xmldoc.xpath("//stem[@type = 'MathML']").each do |x|
           xml_unescape_mathml(x)
           mathml_namespace(x)
           mathml_preserve_space(x)
-          mathml_italicise(x)
           unitsml.MathML2UnitsML(x)
+          mathml_mathvariant(x)
+          mathml_italicise(x)
         end
         mathml_unitsML(xmldoc)
       end

data/lib/asciidoctor/standoc/cleanup_ref.rb

@@ -84,6 +84,11 @@ module Asciidoctor
         biblio_reorder(xmldoc)
         biblio_nested(xmldoc)
         biblio_renumber(xmldoc)
+        biblio_no_ext(xmldoc)
+      end
+
+      def biblio_no_ext(xmldoc)
+        xmldoc.xpath("//bibitem/ext").each(&:remove)
       end
 
       def biblio_nested(xmldoc)

data/lib/asciidoctor/standoc/cleanup_reqt.rb

@@ -3,36 +3,61 @@ module Asciidoctor
     module Cleanup
       def requirement_cleanup(xmldoc)
         requirement_metadata(xmldoc)
-        requirement_descriptions(xmldoc)
         requirement_inherit(xmldoc)
+        requirement_descriptions(xmldoc)
       end
 
       REQRECPER = "//requirement | //recommendation | //permission".freeze
 
       def requirement_inherit(xmldoc)
         xmldoc.xpath(REQRECPER).each do |r|
-          ins = r.at("./classification") ||
-            r.at("./description | ./measurementtarget | ./specification | "\
-                 "./verification | ./import | ./description | ./requirement | "\
-                 "./recommendation | ./permission | ./component")
+          ins = requirement_inherit_insert(r)
           r.xpath("./*//inherit").each { |i| ins.previous = i }
         end
       end
 
+      def requirement_inherit_insert(reqt)
+        ins = reqt.at("./classification") || reqt.at(
+          "./description | ./measurementtarget | ./specification | "\
+          "./verification | ./import | ./description | ./component | "\
+          "./requirement | ./recommendation | ./permission",
+        ) and return ins
+        requirement_inherit_insert1(reqt)
+      end
+
+      def requirement_inherit_insert1(reqt)
+        if t = reqt.at("./title")
+          t.next = " "
+          t.next
+        else
+          if reqt.children.empty? then reqt.add_child(" ")
+          else reqt.children.first.previous = " "
+          end
+          reqt.children.first
+        end
+      end
+
       def requirement_descriptions(xmldoc)
         xmldoc.xpath(REQRECPER).each do |r|
+          r.xpath(".//p[not(./*)][normalize-space(.)='']").each(&:remove)
           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", r)
-              e.before(t)
-              t.children = e.remove
-            end
+            requirement_description_wrap(r, e)
           end
           requirement_description_cleanup1(r)
         end
       end
 
+      def requirement_description_wrap(reqt, text)
+        return if text.element? && (reqt_subpart(text.name) ||
+                %w(requirement recommendation
+                   permission).include?(text.name)) ||
+          text.text.strip.empty?
+
+        t = Nokogiri::XML::Element.new("description", reqt)
+        text.before(t)
+        t.children = text.remove
+      end
+
       def requirement_description_cleanup1(reqt)
         while d = reqt.at("./description[following-sibling::*[1]"\
                           "[self::description]]")
@@ -47,21 +72,34 @@ module Asciidoctor
       def requirement_metadata(xmldoc)
         xmldoc.xpath(REQRECPER).each do |r|
           dl = r&.at("./dl[@metadata = 'true']")&.remove or next
-          requirement_metadata1(r, dl)
+          requirement_metadata1(r, dl, r.at("./title"))
         end
       end
 
-      def requirement_metadata1(reqt, dlist)
-        unless ins = reqt.at("./title")
+      def requirement_metadata1_tags
+        %w(label subject inherit)
+      end
+
+      def requirement_metadata1(reqt, dlist, ins)
+        unless ins
           reqt.children.first.previous = " "
           ins = reqt.children.first
         end
-        %w(label subject inherit).each do |a|
+        %w(obligation model type).each do |a|
+          reqt_dl_to_attrs(reqt, dlist, a)
+        end
+        requirement_metadata1_tags.each do |a|
           ins = reqt_dl_to_elems(ins, reqt, dlist, a)
         end
         reqt_dl_to_classif(ins, reqt, dlist)
       end
 
+      def reqt_dl_to_attrs(reqt, dlist, name)
+        e = dlist.at("./dt[text()='#{name}']") or return
+        val = e.at("./following::dd/p") || e.at("./following::dd") or return
+        reqt[name] = val.text
+      end
+
       def reqt_dl_to_elems(ins, reqt, dlist, name)
         if a = reqt.at("./#{name}[last()]")
           ins = a
@@ -76,16 +114,16 @@ module Asciidoctor
       end
 
       def reqt_dl_to_classif(ins, reqt, dlist)
-        if a = reqt.at("./classification[last()]")
-          ins = a
-        end
+        if a = reqt.at("./classification[last()]") then ins = a end
         dlist.xpath("./dt[text()='classification']").each do |e|
           val = e.at("./following::dd/p") || e.at("./following::dd")
           req_classif_parse(val.text).each do |r|
             ins.next = "<classification><tag>#{r[0]}</tag>"\
                        "<value>#{r[1]}</value></classification>"
+            ins = ins.next
           end
         end
+        ins
       end
     end
   end

data/lib/asciidoctor/standoc/cleanup_section.rb

@@ -114,6 +114,7 @@ module Asciidoctor
         sections_order_cleanup(xml)
         sections_level_cleanup(xml)
         sections_names_cleanup(xml)
+        sections_variant_title_cleanup(xml)
         change_clauses(xml)
       end
 

data/lib/asciidoctor/standoc/cleanup_section_names.rb

@@ -37,39 +37,56 @@ module Asciidoctor
       end
 
       def section_names_refs_cleanup(xml)
-        replace_title(xml, "//references[@normative = 'true']",
+        replace_title(xml, "//bibliography/references[@normative = 'true']",
                       @i18n&.normref, true)
-        replace_title(xml, "//references[@normative = 'false']",
+        replace_title(xml, "//bibliography/references[@normative = 'false']",
                       @i18n&.bibliography, true)
       end
 
       NO_SYMABBR = "[.//definitions[not(@type)]]".freeze
       SYMABBR = "[.//definitions[@type = 'symbols']]"\
-        "[.//definitions[@type = 'abbreviated_terms']]".freeze
+                "[.//definitions[@type = 'abbreviated_terms']]".freeze
       SYMnoABBR = "[.//definitions[@type = 'symbols']]"\
-        "[not(.//definitions[@type = 'abbreviated_terms'])]".freeze
+                  "[not(.//definitions[@type = 'abbreviated_terms'])]".freeze
       ABBRnoSYM = "[.//definitions[@type = 'abbreviated_terms']]"\
-        "[not(.//definitions[@type = 'symbols'])]".freeze
+                  "[not(.//definitions[@type = 'symbols'])]".freeze
 
-      def section_names_terms_cleanup(x)
-        replace_title(x, "//definitions[@type = 'symbols']", @i18n&.symbols)
-        replace_title(x, "//definitions[@type = 'abbreviated_terms']",
+      def section_names_terms_cleanup(xml)
+        replace_title(xml, "//definitions[@type = 'symbols']", @i18n&.symbols)
+        replace_title(xml, "//definitions[@type = 'abbreviated_terms']",
                       @i18n&.abbrev)
-        replace_title(x, "//definitions[not(@type)]", @i18n&.symbolsabbrev)
-        replace_title(x, "//terms#{SYMnoABBR} | //clause[.//terms]#{SYMnoABBR}",
+        replace_title(xml, "//definitions[not(@type)]", @i18n&.symbolsabbrev)
+        replace_title(xml, "//terms#{SYMnoABBR} | //clause[.//terms]#{SYMnoABBR}",
                       @i18n&.termsdefsymbols, true)
-        replace_title(x, "//terms#{ABBRnoSYM} | //clause[.//terms]#{ABBRnoSYM}",
+        replace_title(xml, "//terms#{ABBRnoSYM} | //clause[.//terms]#{ABBRnoSYM}",
                       @i18n&.termsdefabbrev, true)
-        replace_title(x, "//terms#{SYMABBR} | //clause[.//terms]#{SYMABBR}",
+        replace_title(xml, "//terms#{SYMABBR} | //clause[.//terms]#{SYMABBR}",
                       @i18n&.termsdefsymbolsabbrev, true)
-        replace_title(x, "//terms#{NO_SYMABBR} | //clause[.//terms]#{NO_SYMABBR}",
+        replace_title(xml, "//terms#{NO_SYMABBR} | //clause[.//terms]#{NO_SYMABBR}",
                       @i18n&.termsdefsymbolsabbrev, true)
         replace_title(
-          x,
+          xml,
           "//terms[not(.//definitions)] | //clause[.//terms][not(.//definitions)]",
           @i18n&.termsdef, true
         )
       end
+
+      SECTION_CONTAINERS = %w(foreword introduction acknowledgements abstract
+                              clause clause references terms definitions annex
+                              appendix).freeze
+
+      def sections_variant_title_cleanup(xml)
+        path = SECTION_CONTAINERS.map { |x| "./ancestor::#{x}" }.join(" | ")
+        xml.xpath("//p[@variant_title]").each do |p|
+          p.name = "variant-title"
+          p.delete("id")
+          p.delete("variant_title")
+          p.xpath("(#{path})[last()]").each do |sect|
+            ins = sect.at("./title") and ins.next = p or
+              sect.children.first.previous = p
+          end
+        end
+      end
     end
   end
 end

data/lib/asciidoctor/standoc/cleanup_table.rb

@@ -0,0 +1,68 @@
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def dl1_table_cleanup(xmldoc)
+        q = "//table/following-sibling::*[1][self::dl]"
+        xmldoc.xpath(q).each do |s|
+          s["key"] == "true" and s.previous_element << s.remove
+        end
+      end
+
+      # move Key dl after table footer
+      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&.name == "dl"
+            s.next_element["key"] = "true"
+            s.previous_element << s.next_element.remove
+            s.remove
+          end
+        end
+      end
+
+      def insert_thead(table)
+        thead = table.at("./thead")
+        return thead unless thead.nil?
+
+        if tname = table.at("./name")
+          thead = tname.add_next_sibling("<thead/>").first
+          return thead
+        end
+        table.children.first.add_previous_sibling("<thead/>").first
+      end
+
+      def header_rows_cleanup(xmldoc)
+        xmldoc.xpath("//table[@headerrows]").each do |s|
+          thead = insert_thead(s)
+          (thead.xpath("./tr").size...s["headerrows"].to_i).each do
+            row = s.at("./tbody/tr")
+            row.parent = thead
+          end
+          thead.xpath(".//td").each { |n| n.name = "th" }
+          s.delete("headerrows")
+        end
+      end
+
+      def table_cleanup(xmldoc)
+        dl1_table_cleanup(xmldoc)
+        dl2_table_cleanup(xmldoc)
+        notes_table_cleanup(xmldoc)
+        header_rows_cleanup(xmldoc)
+      end
+
+      # move notes into table
+      def notes_table_cleanup(xmldoc)
+        nomatches = false
+        until nomatches
+          nomatches = true
+          xmldoc.xpath("//table/following-sibling::*[1]"\
+                       "[self::note[not(@keep-separate = 'true')]]").each do |n|
+            n.delete("keep-separate")
+            n.previous_element << n.remove
+            nomatches = false
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/cleanup_terms.rb

@@ -29,7 +29,7 @@ module Asciidoctor
       end
 
       def termdefinition_cleanup(xmldoc)
-        xmldoc.xpath("//term").each do |d|
+        xmldoc.xpath("//term[not(definition)]").each do |d|
           first_child = d.at("./p | ./figure | ./formula") || next
           t = Nokogiri::XML::Element.new("definition", xmldoc)
           first_child.replace(t)