metanorma-standoc 1.10.3 → 1.10.5

data/lib/asciidoctor/standoc/cleanup_reqt.rb

@@ -1,40 +1,42 @@
 module Asciidoctor
   module Standoc
     module Cleanup
-      def requirement_cleanup(reqt)
-        requirement_descriptions(reqt)
-        requirement_inherit(reqt)
+      def requirement_cleanup(xmldoc)
+        requirement_metadata(xmldoc)
+        requirement_descriptions(xmldoc)
+        requirement_inherit(xmldoc)
       end
 
-      def requirement_inherit(reqt)
-        reqt.xpath("//requirement | //recommendation | //permission")
-          .each do |r|
+      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")
+                 "./recommendation | ./permission | ./component")
           r.xpath("./*//inherit").each { |i| ins.previous = i }
         end
       end
 
-      def requirement_descriptions(reqt)
-        reqt.xpath("//requirement | //recommendation | //permission")
-          .each do |r|
+      def requirement_descriptions(xmldoc)
+        xmldoc.xpath(REQRECPER).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", reqt)
+              next if e.text.strip.empty?
+              t = Nokogiri::XML::Element.new("description", r)
               e.before(t)
               t.children = e.remove
             end
           end
-          requirement_cleanup1(r)
+          requirement_description_cleanup1(r)
         end
       end
 
-      def requirement_cleanup1(reqt)
+      def requirement_description_cleanup1(reqt)
         while d = reqt.at("./description[following-sibling::*[1]"\
-            "[self::description]]")
+                          "[self::description]]")
           n = d.next.remove
           d << n.children
         end
@@ -42,6 +44,50 @@ module Asciidoctor
           r.replace("\n")
         end
       end
+
+      def requirement_metadata(xmldoc)
+        xmldoc.xpath(REQRECPER).each do |r|
+          dl = r&.at("./dl[@metadata = 'true']")&.remove or next
+          requirement_metadata1(r, dl)
+        end
+      end
+
+      def requirement_metadata1(reqt, dlist)
+        unless ins = reqt.at("./title")
+          reqt.children.first.previous = " "
+          ins = reqt.children.first
+        end
+        %w(label subject inherit).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_elems(ins, reqt, dlist, name)
+        if a = reqt.at("./#{name}[last()]")
+          ins = a
+        end
+        dlist.xpath("./dt[text()='#{name}']").each do |e|
+          val = e.at("./following::dd/p") || e.at("./following::dd")
+          val.name = name
+          ins.next = val
+          ins = ins.next
+        end
+        ins
+      end
+
+      def reqt_dl_to_classif(ins, reqt, dlist)
+        if a = reqt.at("./classification[last()]")
+          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>"
+          end
+        end
+      end
     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.xpath("(#{path})[last()]").each do |sect|
+            p.name = "variant-title"
+            p.delete("id")
+            if ins = sect.at("./title") then ins.next = p
+            else sect.children.first.previous = p
+            end
+          end
+        end
+      end
     end
   end
 end

data/lib/asciidoctor/standoc/cleanup_text.rb

@@ -0,0 +1,70 @@
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def textcleanup(result)
+        text = result.flatten.map { |l| l.sub(/\s*$/, "") } * "\n"
+        !@keepasciimath and text = asciimath2mathml(text)
+        text = text.gsub(/\s+<fn /, "<fn ")
+        text.gsub(%r{<passthrough\s+formats="metanorma">([^<]*)
+                  </passthrough>}mx) { HTMLEntities.new.decode($1) }
+      end
+
+            IGNORE_DUMBQUOTES = "//pre | //pre//* | //tt | //tt//* | "\
+        "//sourcecode | //sourcecode//* | //bibdata//* | //stem | "\
+        "//stem//* | //figure[@class = 'pseudocode'] | "\
+        "//figure[@class = 'pseudocode']//*".freeze
+
+      def smartquotes_cleanup(xmldoc)
+        xmldoc.xpath("//date").each { |d| Metanorma::Utils::endash_date(d) }
+        if @smartquotes then smartquotes_cleanup1(xmldoc)
+        else dumbquote_cleanup(xmldoc)
+        end
+      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|
+          next if !x.ancestors("pre, tt, sourcecode, stem, figure").empty?
+          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(HTMLEntities.new.decode(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|
+            next unless n.text?
+
+            /[-'"(<>]|\.\.|\dx/.match(n) or next
+
+            n.replace(Metanorma::Utils::smartformat(n.text))
+          end
+        end
+      end
+
+      def dumbquote_cleanup(xmldoc)
+        xmldoc.traverse do |n|
+          next unless n.text?
+
+          n.replace(n.text.gsub(/(?<=\p{Alnum})\u2019(?=\p{Alpha})/, "'")) # .
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/converter.rb

@@ -27,6 +27,7 @@ module Asciidoctor
         preprocessor Metanorma::Plugin::Datastruct::Yaml2TextPreprocessor
         preprocessor Metanorma::Plugin::Lutaml::LutamlPreprocessor
         preprocessor Metanorma::Plugin::Lutaml::LutamlUmlAttributesTablePreprocessor
+        preprocessor Metanorma::Plugin::Lutaml::LutamlUmlDatamodelDescriptionPreprocessor
         inline_macro Asciidoctor::Standoc::AltTermInlineMacro
         inline_macro Asciidoctor::Standoc::DeprecatedTermInlineMacro
         inline_macro Asciidoctor::Standoc::DomainTermInlineMacro
@@ -48,6 +49,7 @@ module Asciidoctor
         inline_macro Asciidoctor::Standoc::FormSelectMacro
         inline_macro Asciidoctor::Standoc::FormOptionMacro
         inline_macro Asciidoctor::Standoc::ToCInlineMacro
+        inline_macro Metanorma::Plugin::Lutaml::LutamlFigureInlineMacro
         block_macro Metanorma::Plugin::Lutaml::LutamlDiagramBlockMacro
         block Asciidoctor::Standoc::ToDoAdmonitionBlock
         treeprocessor Asciidoctor::Standoc::ToDoInlineAdmonitionBlock

data/lib/asciidoctor/standoc/isodoc.rng

@@ -32,6 +32,18 @@
         <ref name="DocumentType"/>
       </element>
     </define>
+    <define name="section-title">
+      <element name="title">
+        <zeroOrMore>
+          <ref name="TextElement"/>
+        </zeroOrMore>
+      </element>
+      <zeroOrMore>
+        <element name="variant-title">
+          <ref name="TypedTitleString"/>
+        </element>
+      </zeroOrMore>
+    </define>
     <define name="hyperlink">
       <element name="link">
         <attribute name="target">
@@ -158,15 +170,17 @@
             <data type="boolean"/>
           </attribute>
         </optional>
-        <attribute name="type">
-          <choice>
-            <value>roman</value>
-            <value>alphabet</value>
-            <value>arabic</value>
-            <value>roman_upper</value>
-            <value>alphabet_upper</value>
-          </choice>
-        </attribute>
+        <optional>
+          <attribute name="type">
+            <choice>
+              <value>roman</value>
+              <value>alphabet</value>
+              <value>arabic</value>
+              <value>roman_upper</value>
+              <value>alphabet_upper</value>
+            </choice>
+          </attribute>
+        </optional>
         <oneOrMore>
           <ref name="li"/>
         </oneOrMore>
@@ -1011,8 +1025,14 @@
       <ref name="imagemap"/>
       <ref name="svgmap"/>
       <ref name="inputform"/>
+      <ref name="toc"/>
     </choice>
   </define>
+  <define name="toc">
+    <element name="toc">
+      <ref name="ul"/>
+    </element>
+  </define>
   <define name="inputform">
     <element name="form">
       <attribute name="id">

data/lib/asciidoctor/standoc/lists.rb

@@ -31,7 +31,7 @@ module Asciidoctor
         c = node.attr?("checked")
         attr_code(
           uncheckedcheckbox: node.attr?("checkbox") ? !c : nil,
-          checkedcheckbox: node.attr?("checkbox") ? c : nil
+          checkedcheckbox: node.attr?("checkbox") ? c : nil,
         )
       end
 
@@ -52,12 +52,14 @@ module Asciidoctor
         return "roman" if style == "lowerroman"
         return "roman_upper" if style == "upperroman"
         return "alphabet_upper" if style == "upperalpha"
+
         style
       end
 
       def ol_attrs(node)
-        attr_code(keep_attrs(node).merge(id: Metanorma::Utils::anchor_or_uuid(node),
-                                         type: olist_style(node.style)))
+        attr_code(keep_attrs(node)
+          .merge(id: Metanorma::Utils::anchor_or_uuid(node),
+                 type: olist_style(node.style)))
       end
 
       def olist(node)
@@ -89,9 +91,10 @@ module Asciidoctor
       end
 
       def dl_attrs(node)
-        attr_code(keep_attrs(node).
-                  merge(id: Metanorma::Utils::anchor_or_uuid(node),
-                        key: node.option?("key") ? "true" : nil))
+        attr_code(keep_attrs(node)
+                  .merge(id: Metanorma::Utils::anchor_or_uuid(node),
+                         metadata: node.option?("metadata") ? "true" : nil,
+                         key: node.option?("key") ? "true" : nil))
       end
 
       def dlist(node)

data/lib/asciidoctor/standoc/reqt.rb

@@ -6,20 +6,23 @@ require "base64"
 module Asciidoctor
   module Standoc
     module Blocks
-      def reqt_subpart(x)
+      def reqt_subpart(name)
         %w(specification measurement-target verification import label
-             subject inherit classification title).include? x
+           component subject inherit classification title).include? name
       end
 
-      def reqt_subpart_attrs(node)
-        attr_code(keep_attrs(node).merge(exclude: node.option?("exclude"),
-                                     type: node.attr("type")))
+      def reqt_subpart_attrs(node, name)
+        klass = node.attr("class") || "component"
+        attr_code(keep_attrs(node)
+          .merge(exclude: node.option?("exclude"),
+                 type: node.attr("type"),
+                 class: name == "component" ? klass : nil))
       end
 
       def requirement_subpart(node)
         name = node.role || node.attr("style")
         noko do |xml|
-          xml.send name, **reqt_subpart_attrs(node) do |o|
+          xml.send name, **reqt_subpart_attrs(node, name) do |o|
             o << node.content
           end
         end
@@ -30,14 +33,15 @@ module Asciidoctor
         HTMLEntities.new.decode(classif).split(/;\s*/).each do |c|
           c1 = c.split(/:\s*/)
           next unless c1.size == 2
-          c1[1].split(/,\s*/).each { |v| ret << [ c1[0], v ] }
+
+          c1[1].split(/,\s*/).each { |v| ret << [c1[0], v] }
         end
         ret
       end
 
-      def requirement_classification(classif, ex)
+      def requirement_classification(classif, out)
         req_classif_parse(classif).each do |r|
-          ex.classification do |c|
+          out.classification do |c|
             c.tag { |t| t << r[0] }
             c.value { |v| v << r[1] }
           end
@@ -46,29 +50,37 @@ module Asciidoctor
 
       def reqt_attrs(node)
         attr_code(keep_attrs(node).merge(id_unnum_attrs(node)).merge(
-          id: Metanorma::Utils::anchor_or_uuid(node),
-          unnumbered: node.option?("unnumbered") ? "true" : nil,
-          number: node.attr("number"),
-          subsequence: node.attr("subsequence"),
-          obligation: node.attr("obligation"),
-          filename: node.attr("filename"),
-          type: node.attr("type"),
-          model: node.attr("model"),
-        ))
+                    id: Metanorma::Utils::anchor_or_uuid(node),
+                    unnumbered: node.option?("unnumbered") ? "true" : nil,
+                    number: node.attr("number"),
+                    subsequence: node.attr("subsequence"),
+                    obligation: node.attr("obligation"),
+                    filename: node.attr("filename"),
+                    type: node.attr("type"),
+                    model: node.attr("model"),
+                  ))
+      end
+
+      def requirement_elems(node, out)
+        node.title and out.title { |t| t << node.title }
+        a = node.attr("label") and out.label do |l|
+          l << a
+        end
+        a = node.attr("subject") and csv_split(a)&.each do |subj|
+          out.subject { |s| s << subj }
+        end
+        a = HTMLEntities.new.decode(node.attr("inherit")) and
+          csv_split(a)&.each do |i|
+            out.inherit { |inh| inh << i }
+          end
+        classif = node.attr("classification") and
+          requirement_classification(classif, out)
       end
 
       def requirement(node, obligation)
-        classif = node.attr("classification")
         noko do |xml|
           xml.send obligation, **reqt_attrs(node) do |ex|
-            node.title and ex.title { |t| t << node.title }
-            node.attr("label") and ex.label { |l| l << node.attr("label") }
-            node.attr("subject") and ex.subject { |s| s << node.attr("subject") }
-            i = HTMLEntities.new.decode(node.attr("inherit"))
-            i&.split(/;\s*/)&.each do |i|
-              ex.inherit { |inh| inh << i }
-            end
-            requirement_classification(classif, ex) if classif
+            requirement_elems(node, ex)
             wrap_in_para(node, ex)
           end
         end.join("\n")