metanorma-standoc 1.9.4 → 1.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d42939fe573eddd8bd58ff20a2e3eaacd3eb9de328afccabba60453a8b94cd43
-  data.tar.gz: e2d2e0f516b11587c5dcc6e8f87d39e4d63095b8e96014e7d1bfa610ceb6bae8
+  metadata.gz: f802ef3bf91b1b1af85aa22ca72569b6a6d74b29ed4389373e6b42e7d364b016
+  data.tar.gz: 55bd7031c2f7a2623955c9d1778b48a5a1666d15a0fe160a8058b544ffe60f92
 SHA512:
-  metadata.gz: 653295f7c1dbdb48a201f0784e6d123058a2ccd0abc018fe9ae68049b9c01f29d0120c3a3ec5a25b968e18fbbf4ca3c85c0da294985f2dcee42ea2d049cdb526
-  data.tar.gz: d36fd8fa5b679f71c780bab99fe4c5a18d58c40e8995065975d87cbc0ce51f6459748c1c5310f3c4419d3058087a78d5e9d481839e4579c2d872d0359852ee28
+  metadata.gz: 59462520c525758884fdeac23103756b75908daf58707c25ed1420c3e7184e6c3cfaaa7ecd3770619cb3f5d7d9eedc9778b96980b5a33fcdedbea015da9e2684
+  data.tar.gz: ad562abbf62b1217ab40c933a1f32fe7dbbc474561c47ff0ed91c7de9e9262e3b0612393d8354eccacf30b034316635f5c84aa80f24cc2d5e6e5650bd918e485

data/.github/workflows/rake.yml

@@ -16,7 +16,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        ruby: [ '3.0', '2.7', '2.6', '2.5', '2.4' ]
+        ruby: [ '3.0', '2.7', '2.6', '2.5' ]
         os: [ ubuntu-latest, windows-latest, macos-latest ]
         experimental: [ false ]
     steps:

data/.rubocop.yml

@@ -7,4 +7,4 @@ inherit_from:
 # ...
 
 AllCops:
-  TargetRubyVersion: 2.4
+  TargetRubyVersion: 2.5

data/lib/asciidoctor/standoc/cleanup_inline.rb

@@ -3,32 +3,54 @@ require "metanorma-utils"
 module Asciidoctor
   module Standoc
     module Cleanup
-      def empty_text_before_first_element(x)
-        x.children.each do |c|
-          return false if c.text? and /\S/.match(c.text)
+      def empty_text_before_first_element(elem)
+        elem.children.each do |c|
+          return false if c.text? && /\S/.match(c.text)
           return true if c.element?
         end
         true
       end
 
-      def strip_initial_space(x)
-        if x.children[0].text?
-          if !/\S/.match(x.children[0].text)
-            x.children[0].remove
-          else
-            x.children[0].content = x.children[0].text.gsub(/^ /, "")
-          end
+      def strip_initial_space(elem)
+        return unless elem.children[0].text?
+
+        if /\S/.match?(elem.children[0].text)
+          elem.children[0].content = elem.children[0].text.gsub(/^ /, "")
+        else
+          elem.children[0].remove
         end
       end
 
       def bookmark_cleanup(xmldoc)
+        li_bookmark_cleanup(xmldoc)
+        dt_bookmark_cleanup(xmldoc)
+      end
+
+      def bookmark_to_id(elem, bookmark)
+        parent = bookmark.parent
+        elem["id"] = bookmark.remove["id"]
+        strip_initial_space(parent)
+      end
+
+      def li_bookmark_cleanup(xmldoc)
         xmldoc.xpath("//li[descendant::bookmark]").each do |x|
-          if x&.elements&.first&.name == "p" &&
-              x&.elements&.first&.elements&.first&.name == "bookmark"
-            if empty_text_before_first_element(x.elements[0])
-              x["id"] = x.elements[0].elements[0].remove["id"]
-              strip_initial_space(x.elements[0])
-            end
+          if x.at("./*[1][local-name() = 'p']/"\
+                  "*[1][local-name() = 'bookmark']") &&
+              empty_text_before_first_element(x.elements[0])
+            bookmark_to_id(x, x.elements[0].elements[0])
+          end
+        end
+      end
+
+      def dt_bookmark_cleanup(xmldoc)
+        xmldoc.xpath("//dt[descendant::bookmark]").each do |x|
+          if x.at("./*[1][local-name() = 'p']/"\
+                  "*[1][local-name() = 'bookmark']") &&
+              empty_text_before_first_element(x.elements[0])
+            bookmark_to_id(x, x.elements[0].elements[0])
+          elsif x.at("./*[1][local-name() = 'bookmark']") &&
+              empty_text_before_first_element(x)
+            bookmark_to_id(x, x.elements[0])
           end
         end
       end
@@ -46,65 +68,67 @@ module Asciidoctor
       LOCALITY_RE = Regexp.new(LOCALITY_REGEX_STR.gsub(/\s/, ""),
                                Regexp::IGNORECASE | Regexp::MULTILINE)
 
-      def tq(x)
-        x.sub(/^"/, "").sub(/"$/, "")
+      def tq(text)
+        text.sub(/^"/, "").sub(/"$/, "")
       end
 
-      def extract_localities(x)
-        f = x&.children&.first or return
+      def extract_localities(elem)
+        f = elem&.children&.first or return
         f.text? or return
         head = f.remove.text
-        tail = x&.children&.remove
-        extract_localities1(x, head)
-        tail and x << tail
+        tail = elem&.children&.remove
+        extract_localities1(elem, head)
+        tail and elem << tail
       end
 
-      def extract_localities1(x, text)
-        b = x.add_child("<localityStack/>").first if LOCALITY_RE.match text
+      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 = x.add_child("<localityStack/>").first if m[:punct] == ";"
+          b = elem.add_child("<localityStack/>").first if m[:punct] == ";"
         end
-        x.add_child(text) if text
+        elem.add_child(text) if text
       end
 
-      def xref_to_eref(x)
-        x["bibitemid"] = x["target"]
-        unless x["citeas"] = @anchors&.dig(x["target"], :xref)
-          @internal_eref_namespaces.include?(x["type"]) or
-          @log.add("Crossreferences", x,
-                   "#{x['target']} does not have a corresponding anchor ID in the bibliography!")
+      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
-        x.delete("target")
-        extract_localities(x) unless x.children.empty?
+        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")
+          else x.delete("type")
           end
         end
       end
 
-      def xref_to_internal_eref(x)
-        a = x["target"].split(":", 3)
-        unless  a.size < 2 || a[0].empty? || a[1].empty?
-          x["target"] = "#{a[0]}_#{a[1]}"
-          a.size > 2 and x.children = %{anchor="#{a[2..-1].join("")}",#{x&.children&.text}}
-          x["type"] = a[0]
+      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]
-          x.name = "eref"
-          xref_to_eref(x)
+          elem.name = "eref"
+          xref_to_eref(elem)
         end
       end
 
@@ -116,10 +140,11 @@ module Asciidoctor
 
       def origin_cleanup(xmldoc)
         xmldoc.xpath("//origin/concept[termref]").each do |x|
-          x.replace(x.children)
+          t = x.at("./termref")
+          x.replace(t)
         end
         xmldoc.xpath("//origin").each do |x|
-          x["citeas"] = @anchors&.dig(x["bibitemid"], :xref) ||
+          x["citeas"] = @anchors&.dig(x["bibitemid"], :xref) or
             @log.add("Crossreferences", x,
                      "#{x['bibitemid']} does not have a corresponding anchor "\
                      "ID in the bibliography!")
@@ -128,68 +153,83 @@ module Asciidoctor
       end
 
       def concept_cleanup(xmldoc)
-        xmldoc.xpath("//concept").each do |x|
-          x.delete("term") if x["term"].empty?
-          if /:/.match(x["key"]) then concept_termbase_cleanup(x)
+        xmldoc.xpath("//concept[not(termxref)]").each do |x|
+          term = x.at("./refterm")
+          term&.remove if term&.text&.empty?
+          x.children.remove if x&.children&.text&.strip&.empty?
+          key_extract_locality(x)
+          if /:/.match?(x["key"]) then concept_termbase_cleanup(x)
           elsif refid? x["key"] then concept_eref_cleanup(x)
-          else
-            concept_xref_cleanup(x)
+          else concept_xref_cleanup(x)
           end
           x.delete("key")
         end
       end
 
-      def concept_termbase_cleanup(x)
-        text = x&.children&.first&.remove&.text
-        termbase, key = x["key"].split(/:/, 2)
-        x.add_child(%(<termref base="#{termbase}" target="#{key}">) +
-                    "#{text}</termref>")
+      def key_extract_locality(elem)
+        return unless /,/.match?(elem["key"])
+
+        elem.add_child("<locality>#{elem['key'].sub(/^[^,]+,/, '')}</locality>")
+        elem["key"] = elem["key"].sub(/,.*$/, "")
+      end
+
+      def concept_termbase_cleanup(elem)
+        t = elem&.at("./xrefrender")&.remove&.children
+        termbase, key = elem["key"].split(/:/, 2)
+        elem.add_child(%(<termref base="#{termbase}" target="#{key}">) +
+                       "#{t&.to_xml}</termref>")
       end
 
-      def concept_xref_cleanup(x)
-        text = x&.children&.first&.remove&.text
-        x.add_child(%(<xref target="#{x['key']}">#{text}</xref>))
+      def concept_xref_cleanup(elem)
+        t = elem&.at("./xrefrender")&.remove&.children
+        elem.add_child(%(<xref target="#{elem['key']}">#{t&.to_xml}</xref>))
       end
 
-      def concept_eref_cleanup(x)
-        x.children = "<eref>#{x.children.to_xml}</eref>"
-        extract_localities(x.first_element_child)
+      def concept_eref_cleanup(elem)
+        t = elem&.at("./xrefrender")&.remove&.children&.to_xml
+        l = elem&.at("./locality")&.remove&.children&.to_xml
+        elem.add_child "<eref bibitemid='#{elem['key']}'>#{l}</eref>"
+        extract_localities(elem.elements[-1])
+        elem.elements[-1].add_child(t) if t
       end
 
-      def to_xreftarget(s)
-        return Metanorma::Utils::to_ncname(s) unless /^[^#]+#.+$/.match(s)
-          /^(?<pref>[^#]+)#(?<suff>.+)$/ =~ s
-        pref = pref.gsub(%r([#{Metanorma::Utils::NAMECHAR}]), "_")
-        suff = suff.gsub(%r([#{Metanorma::Utils::NAMECHAR}]), "_")
+      def to_xreftarget(str)
+        return Metanorma::Utils::to_ncname(str) unless /^[^#]+#.+$/.match?(str)
+
+        /^(?<pref>[^#]+)#(?<suff>.+)$/ =~ str
+        pref = pref.gsub(%r([#{Metanorma::Utils::NAMECHAR}])o, "_")
+        suff = suff.gsub(%r([#{Metanorma::Utils::NAMECHAR}])o, "_")
         "#{pref}##{suff}"
       end
 
       IDREF = "//*/@id | //review/@from | //review/@to | "\
         "//callout/@target | //citation/@bibitemid | //eref/@bibitemid".freeze
 
-      def anchor_cleanup(x)
-        anchor_cleanup1(x)
-        xreftarget_cleanup(x)
+      def anchor_cleanup(elem)
+        anchor_cleanup1(elem)
+        xreftarget_cleanup(elem)
       end
 
-      def anchor_cleanup1(x)
-        x.xpath(IDREF).each do |s|
+      def anchor_cleanup1(elem)
+        elem.xpath(IDREF).each do |s|
           if (ret = Metanorma::Utils::to_ncname(s.value)) != (orig = s.value)
             s.value = ret
             output = s.parent.dup
             output.children.remove
-            @log.add("Anchors", s.parent, "normalised identifier in #{output} from #{orig}")
+            @log.add("Anchors", s.parent,
+                     "normalised identifier in #{output} from #{orig}")
           end
         end
       end
 
-      def xreftarget_cleanup(x)
-        x.xpath("//xref/@target").each do |s|
+      def xreftarget_cleanup(elem)
+        elem.xpath("//xref/@target").each do |s|
           if (ret = to_xreftarget(s.value)) != (orig = s.value)
             s.value = ret
             output = s.parent.dup
             output.children.remove
-            @log.add("Anchors", s.parent, "normalised identifier in #{output} from #{orig}")
+            @log.add("Anchors", s.parent,
+                     "normalised identifier in #{output} from #{orig}")
           end
         end
       end

data/lib/asciidoctor/standoc/cleanup_ref.rb

@@ -149,7 +149,14 @@ module Asciidoctor
         end
       end
 
+      def bibitem_nested_id(xmldoc)
+        xmldoc.xpath("//bibitem//bibitem").each do |b|
+          b.delete("id")
+        end
+      end
+
       def bibitem_cleanup(xmldoc)
+        bibitem_nested_id(xmldoc)
         ref_dl_cleanup(xmldoc)
         fetch_local_bibitem(xmldoc)
       end

data/lib/asciidoctor/standoc/cleanup_terms.rb

@@ -60,15 +60,15 @@ module Asciidoctor
 
       def term_children_cleanup(xmldoc)
         xmldoc.xpath("//term").each do |t|
-          t.xpath("./termnote").each { |n| t << n.remove }
-          t.xpath("./termexample").each { |n| t << n.remove }
-          t.xpath("./termsource").each { |n| t << n.remove }
+          %w(termnote termexample termsource).each do |w|
+            t.xpath("./#{w}").each { |n| t << n.remove }
+          end
         end
-      end 
+      end
 
       def termdef_from_termbase(xmldoc)
         xmldoc.xpath("//term").each do |x|
-          if c = x.at("./origin/termref") and !x.at("./definition")
+          if (c = x.at("./origin/termref")) && !x.at("./definition")
             x.at("./origin").previous = fetch_termbase(c["base"], c.text)
           end
         end
@@ -93,33 +93,34 @@ module Asciidoctor
         termdomain1_cleanup(xmldoc)
         termnote_example_cleanup(xmldoc)
         termdef_subclause_cleanup(xmldoc)
-        term_children_cleanup(xmldoc) 
+        term_children_cleanup(xmldoc)
         termdocsource_cleanup(xmldoc)
-      end   
+      end
 
       # Indices sort after letter but before any following
       # letter (x, x_m, x_1, xa); we use colon to force that sort order.
       # Numbers sort *after* letters; we use thorn to force that sort order.
-      def symbol_key(x)
-        key = x.dup
+      def symbol_key(sym)
+        key = sym.dup
         key.traverse do |n|
           next unless n.name == "math"
+
           n.replace(grkletters(MathML2AsciiMath.m2a(n.to_xml)))
         end
         ret = Nokogiri::XML(key.to_xml)
-        HTMLEntities.new.decode(ret.text.downcase).
-          gsub(/[\[\]\{\}<>\(\)]/, "").gsub(/\s/m, "").
-          gsub(/[[:punct:]]|[_^]/, ":\\0").gsub(/`/, "").
-          gsub(/[0-9]+/, "þ\\0")
+        HTMLEntities.new.decode(ret.text.downcase)
+          .gsub(/[\[\]{}<>()]/, "").gsub(/\s/m, "")
+          .gsub(/[[:punct:]]|[_^]/, ":\\0").gsub(/`/, "")
+          .gsub(/[0-9]+/, "þ\\0")
       end
-        
+
       def grkletters(x)
         x.gsub(/\b(alpha|beta|gamma|delta|epsilon|zeta|eta|theta|iota|kappa|lambda|mu|nu|xi|omicron|pi|rho|sigma|tau|upsilon|phi|chi|psi|omega)\b/i, "&\\1;")
       end
 
-      def extract_symbols_list(dl)
+      def extract_symbols_list(dlist)
         dl_out = []
-        dl.xpath("./dt | ./dd").each do |dtd|
+        dlist.xpath("./dt | ./dd").each do |dtd|
           if dtd.name == "dt"
             dl_out << { dt: dtd.remove, key: symbol_key(dtd) }
           else
@@ -128,7 +129,7 @@ module Asciidoctor
         end
         dl_out
       end
-          
+
       def symbols_cleanup(docxml)
         docxml.xpath("//definitions/dl").each do |dl|
           dl_out = extract_symbols_list(dl)
@@ -136,7 +137,7 @@ module Asciidoctor
           dl.children = dl_out.map { |d| d[:dt].to_s + d[:dd].to_s }.join("\n")
         end
         docxml
-      end 
+      end
     end
   end
 end

data/lib/asciidoctor/standoc/inline.rb

@@ -46,13 +46,13 @@ module Asciidoctor
       def inline_anchor_xref_attrs(node)
         m = /^(?<drop>droploc%)?(?<case>capital%|lowercase%)?(?<drop2>droploc%)?
           (?<fn>fn:?\s*)?(?<text>.*)$/x.match node.text
-        casing = m.nil? ? nil : m[:case]&.sub(/%$/, "")
-        droploc = m.nil? ? nil : ((m[:drop].nil? && m[:drop2].nil?) ? nil: true)
-        f = (m.nil? || m[:fn].nil?) ? "inline" : "footnote"
-        c = (!m.nil? && (%i[case fn drop drop2].any? { |x| !m[x].nil? })) ?
-          m[:text] : node.text
         t = node.target.gsub(/^#/, "").gsub(%r{(\.xml|\.adoc)(#.*$)}, "\\2")
-        { target: t, type: f, case: casing, droploc: droploc, text: c }
+        m.nil? and return { target: t, type: "inline", text: node.text }
+        droploc = m[:drop].nil? && m[:drop2].nil? ? nil : true
+        f = m[:fn].nil? ? "inline" : "footnote"
+        c = %i[case fn drop drop2].any? { |x| !m[x].nil? } ? m[:text] : node.text
+        { target: t, type: f, case: m[:case]&.sub(/%$/, ""), droploc: droploc,
+          text: c }
       end
 
       def inline_anchor_link(node)
@@ -115,12 +115,12 @@ module Asciidoctor
 
       def xml_encode(text)
         HTMLEntities.new.encode(text, :basic, :hexadecimal)
-          .gsub(/&amp;gt;/, ">").gsub(/\&amp;lt;/, "<").gsub(/&amp;amp;/, "&")
+          .gsub(/&amp;gt;/, ">").gsub(/&amp;lt;/, "<").gsub(/&amp;amp;/, "&")
           .gsub(/&gt;/, ">").gsub(/&lt;/, "<").gsub(/&amp;/, "&")
           .gsub(/&quot;/, '"').gsub(/&#xa;/, "\n").gsub(/&amp;#/, "&#")
       end
 
-      def latex_parse(text)
+      def latex_parse1(text)
         lxm_input = Unicode2LaTeX.unicode2latex(HTMLEntities.new.decode(text))
         results = Latexmath.parse(lxm_input).to_mathml
         results.nil? and
@@ -134,16 +134,19 @@ module Asciidoctor
           <([^:>&]+:)?math(\s+[^>&]+)?>/x.match? text
           math = xml_encode(text)
           xml.stem math, **{ type: "MathML" }
-        elsif style == :latexmath
-          latex = latex_parse(text) or return xml.stem **{ type: "MathML" }
-          xml.stem **{ type: "MathML" } do |s|
-            math = Nokogiri::XML.fragment(latex.sub(/<\?[^>]+>/, ""))
-              .elements[0]
-            math.delete("alttext")
-            s.parent.children = math
-          end
+        elsif style == :latexmath then latex_parse(text, xml)
         else
-          xml.stem text&.gsub(/\&amp;#/, "&#"), **{ type: "AsciiMath" }
+          xml.stem text&.gsub(/&amp;#/, "&#"), **{ type: "AsciiMath" }
+        end
+      end
+
+      def latex_parse(text, xml)
+        latex = latex_parse1(text) or return xml.stem **{ type: "MathML" }
+        xml.stem **{ type: "MathML" } do |s|
+          math = Nokogiri::XML.fragment(latex.sub(/<\?[^>]+>/, ""))
+            .elements[0]
+          math.delete("alttext")
+          s.parent.children = math
         end
       end