metanorma-standoc 1.10.2 → 1.10.4.1

data/lib/asciidoctor/standoc/isodoc.rng

@@ -1011,8 +1011,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">
@@ -1254,6 +1260,12 @@
     <optional>
       <attribute name="type"/>
     </optional>
+    <optional>
+      <attribute name="identifier"/>
+    </optional>
+    <optional>
+      <attribute name="prefix"/>
+    </optional>
     <text/>
   </define>
   <define name="ics">

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

@@ -2,6 +2,7 @@ require "asciidoctor/extensions"
 require "fileutils"
 require "uuidtools"
 require "yaml"
+require "csv"
 require_relative "./macros_plantuml"
 require_relative "./macros_terms"
 require_relative "./macros_form"
@@ -211,5 +212,22 @@ module Asciidoctor
         %{<del>#{out}</del>}
       end
     end
+
+    class ToCInlineMacro < Asciidoctor::Extensions::InlineMacroProcessor
+      use_dsl
+      named :toc
+      parse_content_as :text
+      using_format :short
+
+      def process(parent, _target, attrs)
+        out = Asciidoctor::Inline.new(parent, :quoted, attrs["text"]).convert
+        content = CSV.parse_line(out).map do |x|
+          x.sub!(/^(["'])(.+)\1/, "\\2")
+          m = /^(.*?)(:\d+)?$/.match(x)
+          %{<toc-xpath depth='#{m[2]&.sub(/:/, '') || 1}'>#{m[1]}</toc-xpath>}
+        end.join
+        "<toc>#{content}</toc>"
+      end
+    end
   end
 end

data/lib/asciidoctor/standoc/ref.rb

@@ -4,7 +4,7 @@ module Asciidoctor
   module Standoc
     module Refs
       def iso_publisher(bib, code)
-        code.sub(/ .*$/, "").split(/\//).each do |abbrev|
+        code.sub(/ .*$/, "").split("/").each do |abbrev|
           bib.contributor do |c|
             c.role **{ type: "publisher" }
             c.organization do |org|
@@ -18,75 +18,78 @@ module Asciidoctor
         { format: "text/plain" }
       end
 
-      def ref_attributes(m)
-        { id: m[:anchor], type: "standard" }
+      def ref_attributes(match)
+        { id: match[:anchor], type: "standard" }
       end
 
-      def isorefrender1(bib, m, yr, allp = "")
-        bib.title(**plaintxt) { |i| i << ref_normalise(m[:text]) }
-        docid(bib, m[:usrlbl]) if m[:usrlbl]
-        docid(bib, id_and_year(m[:code], yr) + allp)
-        docnumber(bib, m[:code])
+      def isorefrender1(bib, match, yr, allp = "")
+        bib.title(**plaintxt) { |i| i << ref_normalise(match[:text]) }
+        docid(bib, match[:usrlbl]) if match[:usrlbl]
+        docid(bib, id_and_year(match[:code], yr) + allp)
+        docnumber(bib, match[:code])
       end
 
-      def isorefmatches(xml, m)
-        yr = norm_year(m[:year])
-        ref = fetch_ref xml, m[:code], yr, title: m[:text], usrlbl: m[:usrlbl],
-          lang: (@lang || :all)
-        return use_my_anchor(ref, m[:anchor]) if ref
+      def isorefmatches(xml, match)
+        yr = norm_year(match[:year])
+        ref = fetch_ref xml, match[:code], yr,
+                        title: match[:text], usrlbl: match[:usrlbl],
+                        lang: (@lang || :all)
+        return use_my_anchor(ref, match[:anchor]) if ref
 
-        xml.bibitem **attr_code(ref_attributes(m)) do |t|
-          isorefrender1(t, m, yr)
+        xml.bibitem **attr_code(ref_attributes(match)) do |t|
+          isorefrender1(t, match, yr)
           yr and t.date **{ type: "published" } do |d|
             set_date_range(d, yr)
           end
-          iso_publisher(t, m[:code])
+          iso_publisher(t, match[:code])
         end
       end
 
-      def isorefmatches2(xml, m)
-        ref = fetch_ref xml, m[:code], nil, no_year: true, note: m[:fn],
-          title: m[:text], usrlbl: m[:usrlbl], lang: (@lang || :all)
-        return use_my_anchor(ref, m[:anchor]) if ref
+      def isorefmatches2(xml, match)
+        ref = fetch_ref xml, match[:code], nil,
+                        no_year: true, note: match[:fn],
+                        title: match[:text], usrlbl: match[:usrlbl],
+                        lang: (@lang || :all)
+        return use_my_anchor(ref, match[:anchor]) if ref
 
-        isorefmatches2_1(xml, m)
+        isorefmatches2_1(xml, match)
       end
 
-      def isorefmatches2_1(xml, m)
-        xml.bibitem **attr_code(ref_attributes(m)) do |t|
-          isorefrender1(t, m, "--")
+      def isorefmatches2_1(xml, match)
+        xml.bibitem **attr_code(ref_attributes(match)) do |t|
+          isorefrender1(t, match, "--")
           t.date **{ type: "published" } do |d|
             d.on "--"
           end
-          iso_publisher(t, m[:code])
-          unless m[:fn].nil?
+          iso_publisher(t, match[:code])
+          unless match[:fn].nil?
             t.note(**plaintxt.merge(type: "Unpublished-Status")) do |p|
-            p << (m[:fn]).to_s
+              p << (match[:fn]).to_s
             end
           end
         end
       end
 
-      def isorefmatches3(xml, m)
-        yr = norm_year(m[:year])
+      def isorefmatches3(xml, match)
+        yr = norm_year(match[:year])
         hasyr = !yr.nil? && yr != "--"
-        ref = fetch_ref(xml, m[:code], hasyr ? yr : nil,
-                        all_parts: true,
-                        no_year: yr == "--", text: m[:text], usrlbl: m[:usrlbl],
+        ref = fetch_ref(xml, match[:code], hasyr ? yr : nil,
+                        all_parts: true, no_year: yr == "--",
+                        text: match[:text], usrlbl: match[:usrlbl],
                         lang: (@lang || :all))
-        return use_my_anchor(ref, m[:anchor]) if ref
+        return use_my_anchor(ref, match[:anchor]) if ref
 
-        isorefmatches3_1(xml, m, yr, hasyr, ref)
+        isorefmatches3_1(xml, match, yr, hasyr, ref)
       end
 
-      def isorefmatches3_1(xml, m, yr, _hasyr, _ref)
-        xml.bibitem(**attr_code(ref_attributes(m))) do |t|
-          isorefrender1(t, m, yr, " (all parts)")
-          conditional_date(t, m, yr == "--")
-          iso_publisher(t, m[:code])
-          if m.names.include?("fn") && m[:fn]
+      def isorefmatches3_1(xml, match, yr, _hasyr, _ref)
+        xml.bibitem(**attr_code(ref_attributes(match))) do |t|
+          isorefrender1(t, match, yr, " (all parts)")
+          conditional_date(t, match, yr == "--")
+          iso_publisher(t, match[:code])
+          if match.names.include?("fn") && match[:fn]
             t.note(**plaintxt.merge(type: "Unpublished-Status")) do |p|
-              p << (m[:fn]).to_s
+              p << (match[:fn]).to_s
             end
           end
           t.extent **{ type: "part" } do |e|
@@ -95,23 +98,23 @@ module Asciidoctor
         end
       end
 
-      def refitem_render1(m, code, bib)
+      def refitem_render1(match, code, bib)
         if code[:type] == "path"
           bib.uri code[:key].sub(/\.[a-zA-Z0-9]+$/, ""), **{ type: "URI" }
           bib.uri code[:key].sub(/\.[a-zA-Z0-9]+$/, ""), **{ type: "citation" }
         end
-        docid(bib, m[:usrlbl]) if m[:usrlbl]
+        docid(bib, match[:usrlbl]) if match[:usrlbl]
         docid(bib, /^\d+$/.match?(code[:id]) ? "[#{code[:id]}]" : code[:id])
         code[:type] == "repo" and
           bib.docidentifier code[:key], **{ type: "repository" }
       end
 
-      def refitem_render(xml, m, code)
-        xml.bibitem **attr_code(id: m[:anchor]) do |t|
+      def refitem_render(xml, match, code)
+        xml.bibitem **attr_code(id: match[:anchor]) do |t|
           t.formattedref **{ format: "application/x-isodoc+xml" } do |i|
-            i << ref_normalise_no_format(m[:text])
+            i << ref_normalise_no_format(match[:text])
           end
-          refitem_render1(m, code, t)
+          refitem_render1(match, code, t)
           docnumber(t, code[:id]) unless /^\d+$|^\(.+\)$/.match?(code[:id])
         end
       end
@@ -128,7 +131,7 @@ module Asciidoctor
 
       def analyse_ref_repo_path(ret)
         return ret unless m =
-          /^(?<type>repo|path):\((?<key>[^,]+),?(?<id>.*)\)$/.match(ret[:id])
+                            /^(?<type>repo|path):\((?<key>[^,]+),?(?<id>.*)\)$/.match(ret[:id])
 
         id = m[:id].empty? ? m[:key].sub(%r{^[^/]+/}, "") : m[:id]
         ret.merge(id: id, type: m[:type], key: m[:key], nofetch: true)
@@ -156,16 +159,17 @@ module Asciidoctor
         nil
       end
 
-      def refitem1(xml, _item, m)
-        code = analyse_ref_code(m[:code])
+      def refitem1(xml, _item, match)
+        code = analyse_ref_code(match[:code])
         unless code[:id] && code[:numeric] || code[:nofetch]
           ref = fetch_ref(xml, code[:id],
-                          m.names.include?("year") ? m[:year] : nil,
-                          title: m[:text],
-                          usrlbl: m[:usrlbl], lang: (@lang || :all))
-          return use_my_anchor(ref, m[:anchor]) if ref
+                          match.names.include?("year") ? match[:year] : nil,
+                          title: match[:text],
+                          usrlbl: match[:usrlbl], lang: (@lang || :all)) and
+            return use_my_anchor(ref, match[:anchor])
         end
-        refitem_render(xml, m, code)
+
+        refitem_render(xml, match, code)
       end
 
       def ref_normalise(ref)
@@ -186,7 +190,7 @@ module Asciidoctor
       \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC)[^0-9]*\s[0-9-]+):
       (--|&\#821[12];)\]</ref>,?\s*
         (<fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>)?,?\s?(?<text>.*)$}xm
-        .freeze
+          .freeze
 
       ISO_REF_ALL_PARTS =
         %r{^<ref\sid="(?<anchor>[^"]+)">

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")

data/lib/asciidoctor/standoc/reqt.rng

@@ -64,9 +64,9 @@
     <optional>
       <ref name="label"/>
     </optional>
-    <optional>
+    <zeroOrMore>
       <ref name="subject"/>
-    </optional>
+    </zeroOrMore>
     <zeroOrMore>
       <ref name="reqinherit"/>
     </zeroOrMore>
@@ -80,6 +80,7 @@
         <ref name="verification"/>
         <ref name="import"/>
         <ref name="description"/>
+        <ref name="component"/>
       </choice>
     </zeroOrMore>
     <optional>
@@ -105,12 +106,16 @@
   </define>
   <define name="subject">
     <element name="subject">
-      <text/>
+      <oneOrMore>
+        <ref name="TextElement"/>
+      </oneOrMore>
     </element>
   </define>
   <define name="reqinherit">
     <element name="inherit">
-      <text/>
+      <oneOrMore>
+        <ref name="TextElement"/>
+      </oneOrMore>
     </element>
   </define>
   <define name="measurementtarget">
@@ -138,6 +143,12 @@
       <ref name="RequirementSubpart"/>
     </element>
   </define>
+  <define name="component">
+    <element name="component">
+      <attribute name="class"/>
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
   <define name="reqt_references">
     <element name="references">
       <oneOrMore>