metanorma-ietf 2.4.0 → 2.4.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a0a93b0a29195d775f23e2ba37414870b8e708a006bba0498b3113aebe787c9
-  data.tar.gz: 53a29d58e5c0c601c29de23d0515d43e690458b8b848f67cacf5064403c3b834
+  metadata.gz: def69cf551c6c50fcb28fcdf04ab02e0d3d9cf83ba3dcd81114c41f71860599f
+  data.tar.gz: 5afc33bb93c93fbc86565d984562a3a61ed02b700e0a1e66a70f47289ef230c9
 SHA512:
-  metadata.gz: e89e41ec81886905668543d6f24ad31ef6ea9cf0a38551f56f1fa3e8007bb6068421b221d0d835951054894146d218b47ae0fe9d1cc1a621f7df6f85a7442e3d
-  data.tar.gz: 11d9d25373f48d7fb3197e5107168c64b8230d519f1e45b410dec5403aab6158f81c8f0e34c2553aff7fa1f32f5974d7a8d7a77a6e5233fb0ef65aa1a300a2c6
+  metadata.gz: 4a2c6f8d47d875c1fb896d1fffdc5d5f789c05a679ab474ae7dfbc52795b9df47eb4763164f08c2da964c0de53ad51f91233ea230a8bce9553a31986f19bf4cd
+  data.tar.gz: eb7fbd7913907b01e95f07bd2b28058b1d8c953f5f9b8b8a9c81a6c1638319fbb2ce8f593a3d83970b5ea748fbf34b7d0ba60b73ea5fa8f9c1a41e3076aec6ac

data/lib/asciidoctor/ietf/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>

data/lib/asciidoctor/ietf/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>

data/lib/isodoc/ietf/blocks.rb

@@ -1,229 +1,236 @@
-module IsoDoc::Ietf
-  class RfcConvert < ::IsoDoc::Convert
-    def para_attrs(node)
-      { keepWithNext: node["keep-with-next"],
-        keepWithPrevious: node["keep-with-previous"],
-        anchor: node["id"] }
-    end
-
-    def para_parse(node, out)
-      out.t **attr_code(para_attrs(node)) do |p|
-        unless @termdomain.empty?
-          p << "&lt;#{@termdomain}&gt; "
-          @termdomain = ""
+module IsoDoc
+  module Ietf
+    class RfcConvert < ::IsoDoc::Convert
+      def para_attrs(node)
+        { keepWithNext: node["keep-with-next"],
+          keepWithPrevious: node["keep-with-previous"],
+          anchor: node["id"] }
+      end
+
+      def para_parse(node, out)
+        out.t **attr_code(para_attrs(node)) do |p|
+          unless @termdomain.empty?
+            p << "&lt;#{@termdomain}&gt; "
+            @termdomain = ""
+          end
+          node.children.each { |n| parse(n, p) unless n.name == "note" }
         end
-        node.children.each { |n| parse(n, p) unless n.name == "note" }
+        node.xpath(ns("./note")).each { |n| parse(n, out) }
       end
-      node.xpath(ns("./note")).each { |n| parse(n, out) }
-    end
 
-    # NOTE ignoring "bare" attribute, which is tantamount to "empty"
-    def ul_attrs(node)
-      { anchor: node["id"],
-        empty: node["nobullet"],
-        spacing: node["spacing"] }
-    end
+      # NOTE ignoring "bare" attribute, which is tantamount to "empty"
+      def ul_attrs(node)
+        { anchor: node["id"],
+          empty: node["nobullet"],
+          spacing: node["spacing"] }
+      end
 
-    def ul_parse(node, out)
-      out.ul **attr_code(ul_attrs(node)) do |ul|
-        node.children.each { |n| parse(n, ul) }
+      def ul_parse(node, out)
+        out.ul **attr_code(ul_attrs(node)) do |ul|
+          node.children.each { |n| parse(n, ul) }
+        end
       end
-    end
 
-    OL_STYLE = {
-      arabic: "1",
-      roman: "i",
-      alphabet: "a",
-      roman_upper: "I",
-      alphabet_upper: "A",
-    }.freeze
+      OL_STYLE = {
+        arabic: "1",
+        roman: "i",
+        alphabet: "a",
+        roman_upper: "I",
+        alphabet_upper: "A",
+      }.freeze
 
-    def ol_style(type)
-      OL_STYLE[type&.to_sym] || type
-    end
+      def ol_style(type)
+        OL_STYLE[type&.to_sym] || type
+      end
 
-    def ol_attrs(node)
-      { anchor: node["id"],
-        spacing: node["spacing"],
-        type: ol_style(node["type"]),
-        group: node["group"],
-        start: node["start"] }
-    end
+      def ol_attrs(node)
+        { anchor: node["id"],
+          spacing: node["spacing"],
+          type: ol_style(node["type"]),
+          group: node["group"],
+          start: node["start"] }
+      end
 
-    def ol_parse(node, out)
-      out.ol **attr_code(ol_attrs(node)) do |ol|
-        node.children.each { |n| parse(n, ol) }
+      def ol_parse(node, out)
+        out.ol **attr_code(ol_attrs(node)) do |ol|
+          node.children.each { |n| parse(n, ol) }
+        end
       end
-    end
 
-    def dl_attrs(node)
-      attr_code(anchor: node["id"],
-                newline: node["newline"],
-                indent: node["indent"],
-                spacing: node["spacing"])
-    end
+      def dl_attrs(node)
+        attr_code(anchor: node["id"],
+                  newline: node["newline"],
+                  indent: node["indent"],
+                  spacing: node["spacing"])
+      end
 
-    def dt_parse(dt, term)
-      if dt.elements.empty?
-        term << dt.text
-      else
-        dt.children.each { |n| parse(n, term) }
+      def dt_parse(dt, term)
+        if dt.elements.empty?
+          term << dt.text
+        else
+          dt.children.each { |n| parse(n, term) }
+        end
       end
-    end
 
-    def note_label(node)
-      n = @xrefs.get[node["id"]]
-      return l10n("#{@i18n.note}: ") if n.nil? || n[:label].nil? ||
-        n[:label].empty?
+      def note_label(node)
+        n = @xrefs.get[node["id"]]
+        return l10n("#{@i18n.note}: ") if n.nil? || n[:label].nil? ||
+          n[:label].empty?
 
-      l10n("#{@i18n.note} #{n[:label]}: ")
-    end
+        l10n("#{@i18n.note} #{n[:label]}: ")
+      end
 
-    def note_parse(node, out)
-      first = node.first_element_child
-      out.aside **attr_code(anchor: node["id"] || first["id"]) do |a|
-        a.t do |p|
-          p << note_label(node)
-          first.name == "p" and first.children.each { |n| parse(n, p) }
+      def note_parse(node, out)
+        first = node.first_element_child
+        out.aside **attr_code(anchor: node["id"] || first["id"]) do |a|
+          a.t do |p|
+            p << note_label(node)
+            first.name == "p" and first.children.each { |n| parse(n, p) }
+          end
+          first.name == "p" and
+            node.elements.drop(1).each { |n| parse(n, out) } or
+            node.children.each { |n| parse(n, out) }
         end
-        first.name == "p" and
-          node.elements.drop(1).each { |n| parse(n, out) } or
-          node.children.each { |n| parse(n, out) }
       end
-    end
 
-    def example_parse(node, out)
-      example_label(node, out, node.at(ns("./name")))
-      node.elements.each { |n| parse(n, out) unless n.name == "name" }
-    end
+      def example_parse(node, out)
+        example_label(node, out, node.at(ns("./name")))
+        node.elements.each { |n| parse(n, out) unless n.name == "name" }
+      end
 
-    def example_label(node, div, name)
-      n = @xrefs.get[node["id"]]
-      div.t **attr_code(anchor: node["id"], keepWithNext: "true") do |p|
-        lbl = n.nil? || n[:label].nil? || n[:label].empty? ? @i18n.example :
-          l10n("#{@i18n.example} #{n[:label]}")
-        p << lbl
-        name and !lbl.nil? and p << ": "
-        name and name.children.each { |n| parse(n, p) }
+      def example_label(node, div, name)
+        n = @xrefs.get[node["id"]]
+        div.t **attr_code(anchor: node["id"], keepWithNext: "true") do |p|
+          lbl = if n.nil? || n[:label].nil? || n[:label].empty?
+                  @i18n.example
+                else
+                  l10n("#{@i18n.example} #{n[:label]}")
+                end
+          p << lbl
+          name and !lbl.nil? and p << ": "
+          name and name.children.each { |n| parse(n, p) }
+        end
       end
-    end
 
-    def sourcecode_parse(node, out)
-      out.sourcecode **attr_code(
-        anchor: node["id"], type: node["lang"], name: node["filename"],
-        markers: node["markers"], src: node["src"]
-      ) do |s|
-        node.children.each { |x| parse(x, s) unless x.name == "name" }
+      def sourcecode_parse(node, out)
+        out.sourcecode **attr_code(
+          anchor: node["id"], type: node["lang"], name: node["filename"],
+          markers: node["markers"], src: node["src"]
+        ) do |s|
+          node.children.each { |x| parse(x, s) unless x.name == "name" }
+        end
       end
-    end
 
-    def pre_parse(node, out) 
-      out.artwork **attr_code(anchor: node["id"], align: node["align"],
-                              alt: node["alt"], type: "ascii-art") do |s|
-        s.cdata node.text.sub(/^\n/, "").gsub(/\t/, "    ")
+      def pre_parse(node, out)
+        out.artwork **attr_code(anchor: node["id"], align: node["align"],
+                                alt: node["alt"], type: "ascii-art") do |s|
+          s.cdata node.text.sub(/^\n/, "").gsub(/\t/, "    ")
+        end
       end
-    end
 
-    def annotation_parse(node, out)
-      @sourcecode = false
-      @annotation = true
-      node.at("./preceding-sibling::*[local-name() = 'annotation']") or
-        out << "\n\n"
-      callout = node.at(ns("//callout[@target='#{node['id']}']"))
-      out << "\n&lt;#{callout.text}&gt; "
-      out << node&.children&.text&.strip
-      @annotation = false
-    end
+      def annotation_parse(node, out)
+        @sourcecode = false
+        @annotation = true
+        node.at("./preceding-sibling::*[local-name() = 'annotation']") or
+          out << "\n\n"
+        callout = node.at(ns("//callout[@target='#{node['id']}']"))
+        out << "\n&lt;#{callout.text}&gt; "
+        out << node&.children&.text&.strip
+        @annotation = false
+      end
 
-    def formula_where(dl, out)
-      return unless dl
+      def formula_where(dl, out)
+        return unless dl
 
-      out.t { |p| p << @i18n.where }
-      parse(dl, out)
-    end
+        out.t { |p| p << @i18n.where }
+        parse(dl, out)
+      end
 
-    def formula_parse1(node, out)
-      out.t **attr_code(anchor: node["id"]) do |p|
-        parse(node.at(ns("./stem")), p)
-        lbl = @xrefs.anchor(node["id"], :label, false)
-        lbl.nil? or
-          p << "    (#{lbl})"
+      def formula_parse1(node, out)
+        out.t **attr_code(anchor: node["id"]) do |p|
+          parse(node.at(ns("./stem")), p)
+          lbl = @xrefs.anchor(node["id"], :label, false)
+          lbl.nil? or
+            p << "    (#{lbl})"
+        end
       end
-    end
 
-    def formula_parse(node, out)
-      formula_parse1(node, out)
-      formula_where(node.at(ns("./dl")), out)
-      node.children.each do |n|
-        next if %w(stem dl).include? n.name
+      def formula_parse(node, out)
+        formula_parse1(node, out)
+        formula_where(node.at(ns("./dl")), out)
+        node.children.each do |n|
+          next if %w(stem dl).include? n.name
 
-        parse(n, out)
+          parse(n, out)
+        end
       end
-    end
 
-    def quote_attribution(node)
-      author = node&.at(ns("./author"))&.text
-      source = node&.at(ns("./source/@uri"))&.text
-      attr_code(quotedFrom: author, cite: source)
-    end
+      def quote_attribution(node)
+        author = node&.at(ns("./author"))&.text
+        source = node&.at(ns("./source/@uri"))&.text
+        attr_code(quotedFrom: author, cite: source)
+      end
 
-    def quote_parse(node, out)
-      out.blockquote **quote_attribution(node) do |p|
-        node.children.each do |n|
-          parse(n, p) unless ["author", "source"].include? n.name
+      def quote_parse(node, out)
+        out.blockquote **quote_attribution(node) do |p|
+          node.children.each do |n|
+            parse(n, p) unless ["author", "source"].include? n.name
+          end
         end
       end
-    end
 
-    def admonition_name_parse(_node, div, name)
-      div.t **{ keepWithNext: "true" } do |p|
-        name.children.each { |n| parse(n, p) }
+      def admonition_name_parse(_node, div, name)
+        div.t **{ keepWithNext: "true" } do |p|
+          name.children.each { |n| parse(n, p) }
+        end
       end
-    end
 
-    def admonition_parse(node, out)
-      type = node["type"]
-      name = admonition_name(node, type)
-      out.aside **{ anchor: node["id"] } do |t|
-        admonition_name_parse(node, t, name) if name
-        node.children.each { |n| parse(n, t) unless n.name == "name" }
+      def admonition_parse(node, out)
+        type = node["type"]
+        name = admonition_name(node, type)
+        out.aside **{ anchor: node["id"] } do |t|
+          admonition_name_parse(node, t, name) if name
+          node.children.each { |n| parse(n, t) unless n.name == "name" }
+        end
       end
-    end
 
-    def review_note_parse(node, out)
-      out.cref **attr_code(anchor: node["id"], display: node["display"],
-                           source: node["reviewer"]) do |c|
-        name = node.at(ns("./name")) and c.name do |div|
-          name.children.each { |n| parse(n, div) }
+      def review_note_parse(node, out)
+        out.cref **attr_code(anchor: node["id"], display: node["display"],
+                             source: node["reviewer"]) do |c|
+          name = node.at(ns("./name")) and c.name do |div|
+            name.children.each { |n| parse(n, div) }
+          end
+          node.children.each { |n| parse(n, c) unless n.name == "name" }
         end
-        node.children.each { |n| parse(n, c) unless n.name == "name" }
       end
-    end
 
-    def figure_name_parse(_node, div, name)
-      return if name.nil?
+      def figure_name_parse(_node, div, name)
+        return if name.nil?
 
-      div.name do |n|
-        name.children.each { |n| parse(n, div) }
+        div.name do |_n|
+          name.children.each { |n| parse(n, div) }
+        end
       end
-    end
 
-    def pseudocode_parse(node, out)
-      sourcecode_parse(node, out)
-    end
+      def pseudocode_parse(node, out)
+        sourcecode_parse(node, out)
+      end
 
-    def figure_parse(node, out)
-      return pseudocode_parse(node, out) if node["class"] == "pseudocode" ||
-        node["type"] == "pseudocode"
+      def figure_parse(node, out)
+        return pseudocode_parse(node, out) if node["class"] == "pseudocode" ||
+          node["type"] == "pseudocode"
 
-      @in_figure = true
-      out.figure **attr_code(anchor: node["id"]) do |div|
-        figure_name_parse(node, div, node.at(ns("./name")))
-        node.children.each do |n|
-          parse(n, div) unless n.name == "name"
+        @in_figure = true
+        out.figure **attr_code(anchor: node["id"]) do |div|
+          figure_name_parse(node, div, node.at(ns("./name")))
+          node.children.each do |n|
+            parse(n, div) unless n.name == "name"
+          end
         end
+        @in_figure = false
       end
-      @in_figure = false
+
+      def toc_parse(_node, _out); end
     end
   end
 end

data/lib/isodoc/ietf/references.rb

@@ -1,164 +1,174 @@
-module IsoDoc::Ietf
-  class RfcConvert < ::IsoDoc::Convert
-    # TODO displayreference will be implemented as combination of autofetch and user-provided citations
-
-    def bibliography(isoxml, out)
-      isoxml.xpath(ns("//references/bibitem/docidentifier")).each do |i|
-        i.children = docid_prefix(i["type"], i.text)
-      end
-      isoxml.xpath(ns("//bibliography/references | "\
-                      "//bibliography/clause[.//references] | "\
-                      "//annex/clause[.//references] | "\
-                      "//annex/references | "\
-                      "//sections/clause[.//references]")).each do |f|
-        bibliography1(f, out)
+module IsoDoc
+  module Ietf
+    class RfcConvert < ::IsoDoc::Convert
+      # TODO displayreference will be implemented as combination of autofetch and user-provided citations
+
+      def bibliography(isoxml, out)
+        isoxml.xpath(ns("//references/bibitem/docidentifier")).each do |i|
+          i.children = docid_prefix(i["type"], i.text)
+        end
+        isoxml.xpath(ns("//bibliography/references | "\
+                        "//bibliography/clause[.//references] | "\
+                        "//annex/clause[.//references] | "\
+                        "//annex/references | "\
+                        "//sections/clause[.//references]")).each do |f|
+          bibliography1(f, out)
+        end
       end
-    end
 
-    def bibliography1(f, out)
-      out.references **attr_code(anchor: f["id"]) do |div|
-        title = f.at(ns("./title")) and div.name do |name|
-          title.children.each { |n| parse(n, name) }
+      def bibliography1(node, out)
+        out.references **attr_code(anchor: node["id"]) do |div|
+          title = node.at(ns("./title")) and div.name do |name|
+            title.children.each { |n| parse(n, name) }
+          end
+          node.elements.select do |e|
+            %w(references clause).include? e.name
+          end.each { |e| bibliography1(e, out) }
+          node.elements.reject do |e|
+            %w(references title bibitem note).include? e.name
+          end.each { |e| parse(e, div) }
+          biblio_list(node, div, true)
         end
-        f.elements.select do |e|
-          %w(references clause).include? e.name
-        end.each { |e| bibliography1(e, out) }
-        f.elements.reject do |e|
-          %w(references title bibitem note).include? e.name
-        end.each { |e| parse(e, div) }
-        biblio_list(f, div, true)
       end
-    end
 
-    def biblio_list(f, div, biblio)
-      i = 0
-      f.xpath(ns("./bibitem | ./note")).each do |b|
-        next if implicit_reference(b)
+      def biblio_list(node, div, biblio)
+        i = 0
+        node.xpath(ns("./bibitem | ./note")).each do |b|
+          next if implicit_reference(b)
 
-        i += 1 if b.name == "bibitem"
-        if b.name == "note" then note_parse(b, div)
-        elsif is_ietf(b) then ietf_bibitem_entry(div, b, i)
-        else
-          nonstd_bibitem(div, b, i, biblio)
+          i += 1 if b.name == "bibitem"
+          if b.name == "note" then note_parse(b, div)
+          elsif ietf?(b) then ietf_bibitem_entry(div, b, i)
+          else
+            nonstd_bibitem(div, b, i, biblio)
+          end
         end
       end
-    end
 
-    def nonstd_bibitem(list, b, _ordinal, _bibliography)
-      uris = b.xpath(ns("./uri"))
-      target = nil
-      uris&.each do |u|
-        target = u.text if u["type"] == "src"
-      end
-      list.reference **attr_code(target: target,
-                                 anchor: b["id"]) do |r|
-        r.front do |f|
-          relaton_to_title(b, f)
-          relaton_to_author(b, f)
-          relaton_to_date(b, f)
-          relaton_to_keyword(b, f)
-          relaton_to_abstract(b, f)
-        end
-        uris&.each do |u|
-          r.format nil, **attr_code(target: u.text, type: u["type"])
-        end
-        docidentifiers = b.xpath(ns("./docidentifier"))
-        id = render_identifier(bibitem_ref_code(b))
-        !id[1].nil? and id[1] != "(NO ID)" and
-          r.refcontent id[1]
-        docidentifiers&.each do |u|
-          if %w(DOI IETF).include? u["type"]
-            r.seriesInfo nil, **attr_code(value: u.text.sub(/^DOI /, ""),
-                                          name: u["type"])
+      def nonstd_bibitem(list, bib, _ordinal, _bibliography)
+        uris = bib.xpath(ns("./uri"))
+        target = nil
+        uris&.each { |u| target = u.text if u["type"] == "src" }
+        list.reference **attr_code(target: target,
+                                   anchor: bib["id"]) do |r|
+          nonstd_bibitem_front(r, bib)
+          uris&.each do |u|
+            r.format nil, **attr_code(target: u.text, type: u["type"])
+          end
+          docidentifiers = bib.xpath(ns("./docidentifier"))
+          id = render_identifier(bibitem_ref_code(bib))
+          !id[1].nil? && id[1] != "(NO ID)" and r.refcontent id[1]
+          docidentifiers&.each do |u|
+            if %w(DOI IETF).include? u["type"]
+              r.seriesInfo nil, **attr_code(value: u.text.sub(/^DOI /, ""),
+                                            name: u["type"])
+            end
           end
         end
       end
-    end
 
-    def relaton_to_title(b, f)
-      title = b&.at(ns("./title")) || b&.at(ns("./formattedref")) or return
-      f.title do |t|
-        title.children.each { |n| parse(n, t) }
+      def nonstd_bibitem_front(ref, bib)
+        ref.front do |f|
+          relaton_to_title(bib, f)
+          relaton_to_author(bib, f)
+          relaton_to_date(bib, f)
+          relaton_to_keyword(bib, f)
+          relaton_to_abstract(bib, f)
+        end
       end
-    end
 
-    def relaton_to_author(b, f)
-      auths = b.xpath(ns("./contributor[xmlns:role/@type = 'author' or "\
-                         "xmlns:role/@type = 'editor']"))
-      auths.empty? and auths = b.xpath(ns("./contributor[xmlns:role/@type = "\
-                                          "'publisher']"))
-      auths.each do |a|
-        role = a.at(ns("./role[@type = 'editor']")) ? "editor" : nil
-        p = a&.at(ns("./person/name")) and
-          relaton_person_to_author(p, role, f) or
-          relaton_org_to_author(a&.at(ns("./organization")), role, f)
+      def relaton_to_title(bib, node)
+        title = bib&.at(ns("./title")) || bib&.at(ns("./formattedref")) or
+          return
+        node.title do |t|
+          title.children.each { |n| parse(n, t) }
+        end
       end
-    end
 
-    def relaton_person_to_author(p, role, f)
-      fullname = p&.at(ns("./completename"))&.text
-      surname = p&.at(ns("./surname"))&.text
-      initials = p&.xpath(ns("./initial"))&.map { |i| i.text }&.join(" ") ||
-        p&.xpath(ns("./forename"))&.map { |i| i.text[0] }&.join(" ")
-      initials = nil if initials.empty?
-      f.author nil,
-               **attr_code(fullname: fullname, asciiFullname: fullname&.transliterate,
-                           role: role, surname: surname, initials: initials,
-                           asciiSurname: fullname ? surname&.transliterate : nil,
-                           asciiInitials: fullname ? initials&.transliterate : nil)
-    end
+      def relaton_to_author(bib, node)
+        auths = bib.xpath(ns("./contributor[xmlns:role/@type = 'author' or "\
+                             "xmlns:role/@type = 'editor']"))
+        auths.empty? and
+          auths = bib.xpath(ns("./contributor[xmlns:role/@type = "\
+                               "'publisher']"))
+        auths.each do |a|
+          role = a.at(ns("./role[@type = 'editor']")) ? "editor" : nil
+          p = a&.at(ns("./person/name")) and
+            relaton_person_to_author(p, role, node) or
+            relaton_org_to_author(a&.at(ns("./organization")), role, node)
+        end
+      end
 
-    def relaton_org_to_author(o, _role, f)
-      name = o&.at(ns("./name"))&.text
-      abbrev = o&.at(ns("./abbreviation"))&.text
-      f.author do |_a|
-        f.organization name, **attr_code(ascii: name&.transliterate,
-                                         abbrev: abbrev)
+      def relaton_person_to_author(pers, role, node)
+        full = pers&.at(ns("./completename"))&.text
+        surname = pers&.at(ns("./surname"))&.text
+        initials = pers&.xpath(ns("./initial"))&.map do |i|
+                     i.text
+                   end&.join(" ") ||
+          pers&.xpath(ns("./forename"))&.map { |i| i.text[0] }&.join(" ")
+        initials = nil if initials.empty?
+        node.author nil, **attr_code(
+          fullname: full,
+          asciiFullname: full&.transliterate,
+          role: role, surname: surname,
+          initials: initials,
+          asciiSurname: full ? surname&.transliterate : nil,
+          asciiInitials: full ? initials&.transliterate : nil
+        )
       end
-    end
 
-    def relaton_to_date(b, f)
-      date = b.at(ns("./date[@type = 'published']")) ||
-        b.at(ns("./date[@type = 'issued']")) ||
-        b.at(ns("./date[@type = 'circulated']"))
-      return unless date
+      def relaton_org_to_author(org, _role, node)
+        name = org&.at(ns("./name"))&.text
+        abbrev = org&.at(ns("./abbreviation"))&.text
+        node.author do |_a|
+          node.organization name, **attr_code(ascii: name&.transliterate,
+                                              abbrev: abbrev)
+        end
+      end
 
-      attr = date_attr(date&.at(ns("./on | ./from"))&.text) || return
-      f.date **attr_code(attr)
-    end
+      def relaton_to_date(bib, node)
+        date = bib.at(ns("./date[@type = 'published']")) ||
+          bib.at(ns("./date[@type = 'issued']")) ||
+          bib.at(ns("./date[@type = 'circulated']"))
+        return unless date
 
-    def relaton_to_keyword(b, f)
-      b.xpath(ns("./keyword")).each do |k|
-        f.keyword do |keyword|
-          k.children.each { |n| parse(n, keyword) }
+        attr = date_attr(date&.at(ns("./on | ./from"))&.text) || return
+        node.date **attr_code(attr)
+      end
+
+      def relaton_to_keyword(bib, node)
+        bib.xpath(ns("./keyword")).each do |k|
+          node.keyword do |keyword|
+            k.children.each { |n| parse(n, keyword) }
+          end
         end
       end
-    end
 
-    def relaton_to_abstract(b, f)
-      b.xpath(ns("./abstract")).each do |k|
-        f.abstract do |abstract|
-          if k.at(ns("./p"))
-            k.children.each { |n| parse(n, abstract) }
-          else
-            abstract.t do |t|
-              k.children.each { |n| parse(n, t) }
+      def relaton_to_abstract(bib, node)
+        bib.xpath(ns("./abstract")).each do |k|
+          node.abstract do |abstract|
+            if k.at(ns("./p"))
+              k.children.each { |n| parse(n, abstract) }
+            else
+              abstract.t do |t|
+                k.children.each { |n| parse(n, t) }
+              end
             end
           end
         end
       end
-    end
 
-    def ietf_bibitem_entry(div, b, _i)
-      url = b&.at(ns("./uri[@type = 'xml']"))&.text
-      div << "<xi:include href='#{url}'/>"
-    end
+      def ietf_bibitem_entry(div, bib, _idx)
+        url = bib&.at(ns("./uri[@type = 'xml']"))&.text
+        div << "<xi:include href='#{url}'/>"
+      end
 
-    def is_ietf(b)
-      return false if !@xinclude
+      def ietf?(bib)
+        return false if !@xinclude
 
-      url = b.at(ns("./uri[@type = 'xml']")) or return false
-      /xml2rfc\.tools\.ietf\.org/.match(url)
+        url = bib.at(ns("./uri[@type = 'xml']")) or return false
+        /xml2rfc\.tools\.ietf\.org/.match(url)
+      end
     end
   end
 end

data/lib/isodoc/ietf/validation.rb

@@ -1,191 +1,192 @@
 require "jing"
 require "fileutils"
 
-module IsoDoc::Ietf
-  class RfcConvert < ::IsoDoc::Convert
-    def schema_validate(filename)
-      begin
-        errors = Jing.new(File.join(File.dirname(__FILE__), "v3.rng")).
-          validate(filename)
+module IsoDoc
+  module Ietf
+    class RfcConvert < ::IsoDoc::Convert
+      def schema_validate(filename)
+        errors = Jing.new(File.join(File.dirname(__FILE__), "v3.rng"))
+          .validate(filename)
         errors.each do |error|
-          warn "RFC XML: Line #{"%06d" % error[:line]}:#{error[:column]} "\
-            "#{error[:message]}"
+          warn "RFC XML: Line #{'%06d' % error[:line]}:#{error[:column]} "\
+               "#{error[:message]}"
         end
       rescue Jing::Error => e
         abort "Jing failed with error: #{e}"
       end
-    end
 
-    def content_validate(xml, filename)
-      err = []
-      err += numbered_sections_check(xml)
-      err += toc_sections_check(xml)
-      err += references_check(xml)
-      err += xref_check(xml)
-      err += metadata_check(xml)
-      return if err.empty?
-      FileUtils.mv(filename, "#{filename}.err")
-      err.each { |e| warn "RFC XML: #{e}" }
-      warn "Cannot continue processing"
-    end
+      def content_validate(xml, filename)
+        err = []
+        err += numbered_sections_check(xml)
+        err += toc_sections_check(xml)
+        err += references_check(xml)
+        err += xref_check(xml)
+        err += metadata_check(xml)
+        return if err.empty?
 
-    def label(sect)
-      ret = sect&.at("./name")&.text ||
-        sect["name"] || sect["anchor"]
-    end
+        FileUtils.mv(filename, "#{filename}.err")
+        err.each { |e| warn "RFC XML: #{e}" }
+        warn "Cannot continue processing"
+      end
 
-    # 2.46.2.  "numbered" Attribute
-    def numbered_sections_check(xml)
-      ret = []
-      xml.xpath("//section[@numbered = 'false']").each do |s1|
-        s1.xpath("./section[not(@numbered) or @numbered = 'true']").
-          each do |s2|
-          ret << "Numbered section #{label(s2)} under unnumbered section "\
-            "#{label(s1)}"
-        end
-        s1.xpath("./following-sibling::*[name() = 'section']"\
-                 "[not(@numbered) or @numbered = 'true']").each do |s2|
-          ret << "Numbered section #{label(s2)} following unnumbered section "\
-            "#{label(s1)}"
-        end
+      def label(sect)
+        sect&.at("./name")&.text ||
+          sect["name"] || sect["anchor"]
       end
-      ret
-    end
 
-    # 5.2.7.  Section "toc" attribute
-    def toc_sections_check(xml)
-      ret = []
-      xml.xpath("//section[@toc = 'exclude']").each do |s1|
-        s1.xpath(".//section[@toc = 'include']").each do |s2|
-          ret << "Section #{label(s2)} with toc=include is included in "\
-            "section #{label(s1)} with toc=exclude"
+      # 2.46.2.  "numbered" Attribute
+      def numbered_sections_check(xml)
+        ret = []
+        xml.xpath("//section[@numbered = 'false']").each do |s1|
+          s1.xpath("./section[not(@numbered) or @numbered = 'true']")
+            .each do |s2|
+            ret << "Numbered section #{label(s2)} under unnumbered section "\
+                   "#{label(s1)}"
+          end
+          s1.xpath("./following-sibling::*[name() = 'section']"\
+                   "[not(@numbered) or @numbered = 'true']").each do |s2|
+            ret << "Numbered section #{label(s2)} following unnumbered "\
+                   "section #{label(s1)}"
+          end
         end
+        ret
       end
-      ret
-    end
 
-    #  5.4.3  <reference> "target" Insertion
-    #  5.4.2.4  "Table of Contents" Insertion
-    def references_check(xml)
-      ret = []
-      xml.xpath("//reference[not(@target)]").each do |s|
-        s.xpath(".//seriesInfo[@name = 'RFC' or @name = 'Internet-Draft' "\
-                   "or @name = 'DOI'][not(@value)]").each do |s1|
-          ret << "for reference #{s['anchor']}, the seriesInfo with "\
-            "name=#{s1['name']} has been given no value"
+      # 5.2.7.  Section "toc" attribute
+      def toc_sections_check(xml)
+        ret = []
+        xml.xpath("//section[@toc = 'exclude']").each do |s1|
+          s1.xpath(".//section[@toc = 'include']").each do |s2|
+            ret << "Section #{label(s2)} with toc=include is included in "\
+                   "section #{label(s1)} with toc=exclude"
+          end
         end
+        ret
       end
-      xml.xpath("//references | //section").each do |s|
-        s.at("./name") or ret << "Cannot generate table of contents entry "\
-          "for #{label(s)}, as it has no title"
-      end
-      ret
-    end
 
-    # 5.4.8.2.  "derivedContent" Insertion (without Content)
-    def xref_check(xml)
-      ret = []
-      xml.xpath("//xref | //relref").each do |x|
-        t = xml.at(".//*[@anchor = '#{x['target']}']") ||
-          xml.at(".//*[@pn = '#{x['target']}']") or
-          ret << "#{x.name} target #{x['target']} does not exist in the document"
-        next unless t
-        x.delete("relative") if x["relative"]&.empty?
-        x.delete("section") if x["section"]&.empty?
-        if x["format"] == "title" && t.name == "reference"
-          t.at("./front/title") or
-            ret << "reference #{t['anchor']} has been referenced by #{x.name} "\
-            "with format=title, but the reference has no title"
-        end
-        if x["format"] == "counter" && !%w(section table figure li 
-          reference references t dt).include?(t.name)
-          ret << "#{x.to_xml} with format=counter is only allowed for "\
-            "clauses, tables, figures, list entries, definition terms, "\
-            "paragraphs, bibliographies, and bibliographic entries"
-        end
-        if x["format"] == "counter" && t.name == "reference" && !x["section"]
-          ret << "reference #{t['anchor']} has been referenced by xref "\
-            "#{x.to_xml} with format=counter, which requires a "\
-            "section attribute"
-        end
-        if x["format"] == "counter" && t.name == "li" && t.parent.name != "ol"
-          ret << "#{x.to_xml} with format=counter refers to an unnumbered "\
-            "list entry"
-        end
-        if x["format"] == "title" && %w(u author contact).include?(t.name)
-          ret << "#{x.to_xml} with format=title cannot reference a "\
-            "<#{t.name}> element"
-        end
-        if x["relative"] && !x["section"]
-          ret << "#{x.to_xml} with relative attribute requires a section "\
-            "attribute"
-        end
-        if (x["section"]) && t.name != "reference"
-          ret << "#{x.to_xml} has a section attribute, but #{x['target']} "\
-            "points to a #{t.name}"
+      #  5.4.3  <reference> "target" Insertion
+      #  5.4.2.4  "Table of Contents" Insertion
+      def references_check(xml)
+        ret = []
+        xml.xpath("//reference[not(@target)]").each do |s|
+          s.xpath(".//seriesInfo[@name = 'RFC' or @name = 'Internet-Draft' "\
+                  "or @name = 'DOI'][not(@value)]").each do |s1|
+            ret << "for reference #{s['anchor']}, the seriesInfo with "\
+                   "name=#{s1['name']} has been given no value"
+          end
         end
-        if (x["relative"]) && t.name != "reference"
-          ret << "#{x.to_xml} has a relative attribute, but #{x['target']} "\
-            "points to a #{t.name}"
+        xml.xpath("//references | //section").each do |s|
+          s.at("./name") or ret << "Cannot generate table of contents entry "\
+                                   "for #{label(s)}, as it has no title"
         end
-        if !x["relative"] && x["section"]
-          unless t.at(".//seriesInfo[@name = 'RFC' or @name = "\
-              "'Internet-Draft']")
+        ret
+      end
+
+      # 5.4.8.2.  "derivedContent" Insertion (without Content)
+      def xref_check(xml)
+        ret = []
+        xml.xpath("//xref | //relref").each do |x|
+          t = xml.at(".//*[@anchor = '#{x['target']}']") ||
+            xml.at(".//*[@pn = '#{x['target']}']") or
+            ret << "#{x.name} target #{x['target']} does not exist in the document"
+          next unless t
+
+          x.delete("relative") if x["relative"] && x["relative"].empty?
+          x.delete("section") if x["section"] && x["section"].empty?
+          if x["format"] == "title" && t.name == "reference"
+            t.at("./front/title") or
+              ret << "reference #{t['anchor']} has been referenced by #{x.name} "\
+                     "with format=title, but the reference has no title"
+          end
+          if x["format"] == "counter" && !%w(section table figure li
+                                             reference references t dt).include?(t.name)
+            ret << "#{x.to_xml} with format=counter is only allowed for "\
+                   "clauses, tables, figures, list entries, definition terms, "\
+                   "paragraphs, bibliographies, and bibliographic entries"
+          end
+          if x["format"] == "counter" && t.name == "reference" && !x["section"]
+            ret << "reference #{t['anchor']} has been referenced by xref "\
+                   "#{x.to_xml} with format=counter, which requires a "\
+                   "section attribute"
+          end
+          if x["format"] == "counter" && t.name == "li" && t.parent.name != "ol"
+            ret << "#{x.to_xml} with format=counter refers to an unnumbered "\
+                   "list entry"
+          end
+          if x["format"] == "title" && %w(u author contact).include?(t.name)
+            ret << "#{x.to_xml} with format=title cannot reference a "\
+                   "<#{t.name}> element"
+          end
+          if x["relative"] && !x["section"]
+            ret << "#{x.to_xml} with relative attribute requires a section "\
+                   "attribute"
+          end
+          if (x["section"]) && t.name != "reference"
+            ret << "#{x.to_xml} has a section attribute, but #{x['target']} "\
+                   "points to a #{t.name}"
+          end
+          if (x["relative"]) && t.name != "reference"
+            ret << "#{x.to_xml} has a relative attribute, but #{x['target']} "\
+                   "points to a #{t.name}"
+          end
+          if !x["relative"] && x["section"] && !t.at(".//seriesInfo[@name = 'RFC' or @name = "\
+                                                     "'Internet-Draft']")
             ret << "#{x.to_xml} must use a relative attribute, "\
-              "since it does not point to a RFC or Internet-Draft reference"
+                   "since it does not point to a RFC or Internet-Draft reference"
           end
-        end
-        if x["relative"] 
-          unless t.at(".//seriesInfo[@name = 'RFC' or @name = "\
-              "'Internet-Draft']") || t["target"]
+          if x["relative"] && !(t.at(".//seriesInfo[@name = 'RFC' or @name = "\
+                                     "'Internet-Draft']") || t["target"])
             ret << "need an explicit target= URL attribute in the reference "\
-              "pointed to by #{x.to_xml}"
+                   "pointed to by #{x.to_xml}"
           end
         end
+        ret
       end
-      ret
-    end
 
-    def metadata_check(xml)
-      ret = []
-      ret += link_check(xml)
-      ret += seriesInfo_check(xml)
-      ret += ipr_check(xml)
-      ret
-    end
+      def metadata_check(xml)
+        ret = []
+        ret += link_check(xml)
+        ret += seriesInfo_check(xml)
+        ret += ipr_check(xml)
+        ret
+      end
 
-    # 5.6.3.  <link> Processing
-    def link_check(xml)
-      l = xml&.at("//link[@rel = 'convertedFrom']")&.text
-      !l || %r{^https://datatracker\.ietf\.org/doc/draft-}.match(l) or
-        return ["<link rel='convertedFrom'> (:derived-from: document "\
-                "attribute) must start with "\
-                "https://datatracker.ietf.org/doc/draft-"]
-      []
-    end
+      # 5.6.3.  <link> Processing
+      def link_check(xml)
+        l = xml&.at("//link[@rel = 'convertedFrom']")&.text
+        !l || %r{^https://datatracker\.ietf\.org/doc/draft-}.match(l) or
+          return ["<link rel='convertedFrom'> (:derived-from: document "\
+                  "attribute) must start with "\
+                  "https://datatracker.ietf.org/doc/draft-"]
+        []
+      end
 
-    # 5.2.2.  "seriesInfo" Insertion
-    def seriesInfo_check(xml)
-      ret = []
-      xml.root["ipr"] == "none" and return []
-      rfcinfo = xml.at("//seriesInfo[@name = 'RFC']")
-      rfcnumber = xml.root["number"]
-      rfcinfo && rfcnumber && rfcnumber != rfcinfo["value"] and
-        ret << "Mismatch between <rfc number='#{rfcnumber}'> (:docnumber: NUMBER) "\
-        "and <seriesInfo name='RFC' value='#{rfcinfo['value']}'> "\
-        "(:intended-series: TYPE NUMBER)"
-      rfcinfo && !/^\d+$/.match(rfcnumber) and
-        ret << "RFC identifier <rfc number='#{rfcnumber}'> (:docnumber: NUMBER) "\
-        "must be a number"
-      ret
-    end
+      # 5.2.2.  "seriesInfo" Insertion
+      def seriesInfo_check(xml)
+        ret = []
+        xml.root["ipr"] == "none" and return []
+        rfcinfo = xml.at("//seriesInfo[@name = 'RFC']")
+        rfcnumber = xml.root["number"]
+        rfcinfo && rfcnumber && rfcnumber != rfcinfo["value"] and
+          ret << "Mismatch between <rfc number='#{rfcnumber}'> "\
+                 "(:docnumber: NUMBER) "\
+                 "and <seriesInfo name='RFC' value='#{rfcinfo['value']}'> "\
+                 "(:intended-series: TYPE NUMBER)"
+        rfcinfo && !/^\d+$/.match(rfcnumber) and
+          ret << "RFC identifier <rfc number='#{rfcnumber}'> "\
+                 "(:docnumber: NUMBER) must be a number"
+        ret
+      end
 
-    # 5.4.2.3.  "Copyright Notice" Insertion
-    def ipr_check(xml)
-      xml.root["ipr"] or return ["Missing ipr attribute on <rfc> element (:ipr:)"]
-      /trust200902$/.match(xml.root["ipr"]) or
-        return ["Unknown ipr attribute on <rfc> element (:ipr:): #{xml.root['ipr']}"]
-      []
+      # 5.4.2.3.  "Copyright Notice" Insertion
+      def ipr_check(xml)
+        xml.root["ipr"] or
+          return ["Missing ipr attribute on <rfc> element (:ipr:)"]
+        /trust200902$/.match(xml.root["ipr"]) or
+          return ["Unknown ipr attribute on <rfc> element (:ipr:): "\
+                  "#{xml.root['ipr']}"]
+        []
+      end
     end
   end
 end

data/lib/metanorma/ietf/version.rb

@@ -1,5 +1,5 @@
 module Metanorma
   module Ietf
-    VERSION = "2.4.0".freeze
+    VERSION = "2.4.1".freeze
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: metanorma-ietf
 version: !ruby/object:Gem::Version
-  version: 2.4.0
+  version: 2.4.1
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-08-02 00:00:00.000000000 Z
+date: 2021-08-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: isodoc