metanorma-standoc 1.9.4 → 1.10.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: d42939fe573eddd8bd58ff20a2e3eaacd3eb9de328afccabba60453a8b94cd43
-  data.tar.gz: e2d2e0f516b11587c5dcc6e8f87d39e4d63095b8e96014e7d1bfa610ceb6bae8
+  metadata.gz: a43a3db1e4ef2ae43a1b2c7ecd980384cac2ee645668e414c73fd8e53dee3859
+  data.tar.gz: 6f026c1bd2e1d0c5f2f327cdc345af6635ff1c1454479fd42709b9d18fda5e60
 SHA512:
-  metadata.gz: 653295f7c1dbdb48a201f0784e6d123058a2ccd0abc018fe9ae68049b9c01f29d0120c3a3ec5a25b968e18fbbf4ca3c85c0da294985f2dcee42ea2d049cdb526
-  data.tar.gz: d36fd8fa5b679f71c780bab99fe4c5a18d58c40e8995065975d87cbc0ce51f6459748c1c5310f3c4419d3058087a78d5e9d481839e4579c2d872d0359852ee28
+  metadata.gz: 7b20738029106d832a852db8eabf340058cdcbf75d8ce16def000478733c3633ad1144ac1aa2f736a637423c19f90491429fbec591987bc2f4af58bb3c8df087
+  data.tar.gz: 69f3e40acdca71435cda97dbcd33e862ffbacbb4eeaff97e543b971ec2744c72227115013ef2ac3ee88552c64bf413a36c060adf3af58e6ebb86c6b85997b070

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/base.rb

@@ -3,7 +3,6 @@ require "nokogiri"
 require "htmlentities"
 require "json"
 require "pathname"
-require "open-uri"
 require "isodoc"
 require "relaton"
 require "fileutils"

data/lib/asciidoctor/standoc/blocks.rb

@@ -41,7 +41,7 @@ module Asciidoctor
       def form(node)
         noko do |xml|
           xml.form **attr_code(
-            id: Metanorma::Utils::anchor_or_uuid,
+            id: Metanorma::Utils::anchor_or_uuid, class: node.attr("class"),
             name: node.attr("name"), action: node.attr("action")
           ) do |f|
             f << node.content

data/lib/asciidoctor/standoc/cleanup.rb

@@ -1,6 +1,5 @@
 require "nokogiri"
 require "pathname"
-require "open-uri"
 require "html2doc"
 require_relative "./cleanup_block"
 require_relative "./cleanup_footnotes"
@@ -48,6 +47,7 @@ module Asciidoctor
         xref_cleanup(xmldoc)
         concept_cleanup(xmldoc)
         origin_cleanup(xmldoc)
+        bookmark_cleanup(xmldoc)
         termdef_cleanup(xmldoc)
         RelatonIev::iev_cleanup(xmldoc, @bibdb)
         element_name_cleanup(xmldoc)
@@ -58,11 +58,11 @@ module Asciidoctor
         mathml_cleanup(xmldoc)
         script_cleanup(xmldoc)
         docidentifier_cleanup(xmldoc)
-        bookmark_cleanup(xmldoc)
         requirement_cleanup(xmldoc)
         bibdata_cleanup(xmldoc)
         svgmap_cleanup(xmldoc)
         boilerplate_cleanup(xmldoc)
+        toc_cleanup(xmldoc)
         smartquotes_cleanup(xmldoc)
         variant_cleanup(xmldoc)
         para_cleanup(xmldoc)
@@ -85,6 +85,29 @@ module Asciidoctor
       end
 
       def smartquotes_cleanup1(xmldoc)
+        uninterrupt_quotes_around_xml(xmldoc)
+        dumb2smart_quotes(xmldoc)
+      end
+
+      # "abc<tag/>", def => "abc",<tag/> def
+      def uninterrupt_quotes_around_xml(xmldoc)
+        xmldoc.xpath("//*[following::text()[1]"\
+                     "[starts-with(., '\"') or starts-with(., \"'\")]]")
+          .each do |x|
+          uninterrupt_quotes_around_xml1(x)
+        end
+      end
+
+      def uninterrupt_quotes_around_xml1(elem)
+        prev = elem.at(".//preceding::text()[1]") or return
+        /\S$/.match?(prev.text) or return
+        foll = elem.at(".//following::text()[1]")
+        m = /^(["'][[:punct:]]*)(\s|$)/.match(foll&.text) or return
+        foll.content = foll.text.sub(/^(["'][[:punct:]]*)/, "")
+        prev.content = "#{prev.text}#{m[1]}"
+      end
+
+      def dumb2smart_quotes(xmldoc)
         (xmldoc.xpath("//*[child::text()]") - xmldoc.xpath(IGNORE_DUMBQUOTES))
           .each do |x|
           x.children.each do |n|
@@ -167,6 +190,42 @@ module Asciidoctor
           end
         end
       end
+
+      def toc_cleanup(xmldoc)
+        xmldoc.xpath("//p[toc]").each do |x|
+          x.xpath("./toc").reverse.each do |t|
+            x.next = t
+          end
+          x.remove if x.text.strip.empty?
+        end
+        xmldoc.xpath("//toc").each { |t| toc_cleanup1(t, xmldoc) }
+      end
+
+      def toc_index(toc, xmldoc)
+        depths = toc.xpath("./toc-xpath").each_with_object({}) do |x, m|
+          m[x.text] = x["depth"]
+        end
+        depths.keys.each_with_object([]) do |key, arr|
+          xmldoc.xpath(key).each do |x|
+            arr << { text: x.children.to_xml, depth: depths[key].to_i,
+                     target: x.xpath("(./ancestor-or-self::*/@id)[last()]")[0].text,
+                     line: x.line }
+          end
+        end.sort_by { |a| a[:line] }
+      end
+
+      def toc_cleanup1(toc, xmldoc)
+        depth = 1
+        ret = ""
+        toc_index(toc, xmldoc).each do |x|
+          if depth > x[:depth] then ret += "</ul></li>" * (depth - x[:depth])
+          elsif depth < x[:depth] then ret += "<li><ul>" * (x[:depth] - depth)
+          end
+          ret += "<li><xref target='#{x[:target]}'>#{x[:text]}</xref></li>"
+          depth = x[:depth]
+        end
+        toc.children = "<ul>#{ret}</ul>"
+      end
     end
   end
 end

data/lib/asciidoctor/standoc/cleanup_block.rb

@@ -1,6 +1,5 @@
 require "date"
 require "htmlentities"
-require "open-uri"
 
 module Asciidoctor
   module Standoc

data/lib/asciidoctor/standoc/cleanup_boilerplate.rb

@@ -158,11 +158,11 @@ module Asciidoctor
           xmldoc.root << "<bibliography/>" and ins = xmldoc.at("bibliography")
         ins = ins.add_child("<references hidden='true' normative='false'/>").first
         refs.each do |x|
-          ins << <<~END
+          ins << <<~BIB
             <bibitem id="#{x}" type="internal">
             <docidentifier type="repository">#{x.sub(/^#{prefix}_/, "#{prefix}/")}</docidentifier>
             </bibitem>
-          END
+          BIB
         end
       end
 

data/lib/asciidoctor/standoc/cleanup_footnotes.rb

@@ -1,7 +1,6 @@
 require "date"
 require "htmlentities"
 require "json"
-require "open-uri"
 
 module Asciidoctor
   module Standoc

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