metanorma-ietf 2.3.4 → 2.4.1

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

@@ -15,7 +15,7 @@ require_relative "./init"
 
 module IsoDoc::Ietf
   class RfcConvert < ::IsoDoc::Convert
-    def convert1(docxml, filename, dir)
+    def convert1(docxml, _filename, _dir)
       @xrefs.parse docxml
       info docxml, nil
       xml = noko do |xml|
@@ -51,6 +51,7 @@ module IsoDoc::Ietf
     def error_parse(node, out)
       case node.name
       when "bcp14" then bcp14_parse(node, out)
+      when "concept" then concept_parse(node, out)
       else
         text = node.to_xml.gsub(/</, "&lt;").gsub(/>/, "&gt;")
         out.t { |p| p << text }
@@ -59,6 +60,7 @@ module IsoDoc::Ietf
 
     def omit_docid_prefix(prefix)
       return true if prefix == "IETF"
+
       super
     end
 
@@ -67,9 +69,9 @@ module IsoDoc::Ietf
     end
 
     def postprocess(result, filename, _dir)
-      result = from_xhtml(cleanup(to_xhtml(textcleanup(result)))).
-        sub(/<!DOCTYPE[^>]+>\n/, "").
-        sub(/(<rfc[^<]+? )lang="[^"]+"/, "\\1")
+      result = from_xhtml(cleanup(to_xhtml(textcleanup(result))))
+        .sub(/<!DOCTYPE[^>]+>\n/, "")
+        .sub(/(<rfc[^<]+? )lang="[^"]+"/, "\\1")
       File.open(filename, "w:UTF-8") { |f| f.write(result) }
       schema_validate(filename)
       @files_to_delete.each { |f| FileUtils.rm_rf f }

data/lib/isodoc/ietf/section.rb

@@ -33,7 +33,7 @@ module IsoDoc::Ietf
         strict: node&.at(ns("//pi/strict"))&.text || "yes",
         compact: node&.at(ns("//pi/compact"))&.text || "yes",
         subcompact: node&.at(ns("//pi/subcompact"))&.text || "no",
-        toc: node&.at(ns("//pi/toc-include"))&.text,
+        toc: node&.at(ns("//pi/tocinclude"))&.text,
         tocdepth: node&.at(ns("//pi/toc-depth"))&.text || "4",
         symrefs: node&.at(ns("//pi/sym-refs"))&.text || "yes",
         sortrefs: node&.at(ns("//pi/sort-refs"))&.text || "yes",

data/lib/isodoc/ietf/terms.rb

@@ -1,6 +1,5 @@
 module IsoDoc::Ietf
   class RfcConvert < ::IsoDoc::Convert
-
     def definition_parse(node, out)
       node.children.each { |n| parse(n, out) }
     end
@@ -46,7 +45,19 @@ module IsoDoc::Ietf
       clause_parse(node, out)
     end
 
-    def termdocsource_parse(_node, _out)
+    def termdocsource_parse(_node, _out); end
+
+    def concept_parse(node, out)
+      if d = node.at(ns("./renderterm"))
+        out.em do |em|
+          d.children.each { |n| parse(n, em) }
+        end
+        out << " "
+      end
+      out << "[term defined in "
+      r = node.at(ns("./xref | ./eref | ./termref"))
+      parse(r, out)
+      out << "]"
     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