metanorma-ietf 2.3.6 → 2.4.3

data/lib/isodoc/ietf/inline.rb

@@ -1,167 +1,170 @@
 require "mathml2asciimath"
 
-module IsoDoc::Ietf
-  class RfcConvert < ::IsoDoc::Convert
-    def em_parse(node, out)
-      out.em do |e|
-        node.children.each { |n| parse(n, e) }
+module IsoDoc
+  module Ietf
+    class RfcConvert < ::IsoDoc::Convert
+      def em_parse(node, out)
+        out.em do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def sup_parse(node, out)
-      out.sup do |e|
-        node.children.each { |n| parse(n, e) }
+      def sup_parse(node, out)
+        out.sup do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def sub_parse(node, out)
-      out.sub do |e|
-        node.children.each { |n| parse(n, e) }
+      def sub_parse(node, out)
+        out.sub do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def tt_parse(node, out)
-      out.tt do |e|
-        node.children.each { |n| parse(n, e) }
+      def tt_parse(node, out)
+        out.tt do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def strong_parse(node, out)
-      out.strong do |e|
-        node.children.each { |n| parse(n, e) }
+      def strong_parse(node, out)
+        out.strong do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def bcp14_parse(node, out)
-      out.bcp14 do |e|
-        node.children.each { |n| parse(n, e) }
+      def bcp14_parse(node, out)
+        out.bcp14 do |e|
+          node.children.each { |n| parse(n, e) }
+        end
       end
-    end
 
-    def strike_parse(node, out)
-      node.children.each { |n| parse(n, out) }
-    end
+      def strike_parse(node, out)
+        node.children.each { |n| parse(n, out) }
+      end
 
-    def smallcap_parse(node, out)
-      node.children.each { |n| parse(n, out) }
-    end
+      def smallcap_parse(node, out)
+        node.children.each { |n| parse(n, out) }
+      end
 
-    def keyword_parse(node, out)
-      node.children.each { |n| parse(n, out) }
-    end
+      def keyword_parse(node, out)
+        node.children.each { |n| parse(n, out) }
+      end
 
-    def text_parse(node, out)
-      return if node.nil? || node.text.nil?
-      text = node.to_s
-      out << text
-    end
+      def text_parse(node, out)
+        return if node.nil? || node.text.nil?
 
-    def stem_parse(node, out)
-      stem = case node["type"]
-             when "MathML" then MathML2AsciiMath.m2a(node.children.to_xml)
-             else
-               HTMLEntities.new.encode(node.text)
-             end
-      out << "#{@openmathdelim} #{stem} #{@closemathdelim}"
-    end
+        text = node.to_s
+        out << text
+      end
 
-    def page_break(_out)
-    end
+      def stem_parse(node, out)
+        stem = case node["type"]
+               when "MathML" then MathML2AsciiMath.m2a(node.children.to_xml)
+               else HTMLEntities.new.encode(node.text)
+               end
+        out << "#{@openmathdelim} #{stem} #{@closemathdelim}"
+      end
 
-    def pagebreak_parse(_node, _out)
-    end
+      def page_break(_out); end
 
-    def br_parse(node, out)
-      if @sourcecode
+      def pagebreak_parse(_node, _out); end
+
+      def br_parse(_node, out)
         out.br
       end
-    end
 
-    def hr_parse(node, out)
-    end
+      def hr_parse(node, out); end
 
-    def link_parse(node, out)
-      out.eref **attr_code(target: node["target"]) do |l|
-        node.children.each { |n| parse(n, l) }
+      def link_parse(node, out)
+        out.eref **attr_code(target: node["target"]) do |l|
+          node.children.each { |n| parse(n, l) }
+        end
       end
-    end
 
-    def image_parse(node, out, caption)
-      attrs = { src: node["src"], title: node["title"],
-                align: node["align"], name: node["filename"],
-                anchor: node["id"], type: "svg",
-                alt: node["alt"] }
-      out.artwork **attr_code(attrs)
-      image_title_parse(out, caption)
-    end
+      def image_parse(node, out, caption)
+        attrs = { src: node["src"], title: node["title"],
+                  align: node["align"], name: node["filename"],
+                  anchor: node["id"], type: "svg",
+                  alt: node["alt"] }
+        out.artwork **attr_code(attrs)
+        image_title_parse(out, caption)
+      end
 
-    def image_title_parse(out, caption)
-      unless caption.nil?
-        out.t **{ align: "center", keepWithPrevious: "true" } do |p|
-          p << caption.to_s
+      def image_title_parse(out, caption)
+        unless caption.nil?
+          out.t **{ align: "center", keepWithPrevious: "true" } do |p|
+            p << caption.to_s
+          end
         end
       end
-    end
 
-    def xref_parse(node, out)
-      out.xref **attr_code(target: node["target"], format: node["format"],
-                           relative: node["relative"]) do |l|
-                             l << get_linkend(node)
-                           end
-    end
+      def xref_parse(node, out)
+        out.xref **attr_code(target: node["target"], format: node["format"],
+                             relative: node["relative"]) do |l|
+                               l << get_linkend(node)
+                             end
+      end
 
-    def get_linkend(node)
-      contents = node.children.select { |c| !%w{locality localityStack}.include? c.name }.
-        select { |c| !c.text? || /\S/.match(c) }
-      !contents.empty? and
-        return Nokogiri::XML::NodeSet.new(node.document, contents).to_xml
-      ""
-    end
+      def get_linkend(node)
+        contents = node.children.reject do |c|
+                     %w{locality localityStack}.include? c.name
+                   end
+          .select { |c| !c.text? || /\S/.match(c) }
+        !contents.empty? and
+          return Nokogiri::XML::NodeSet.new(node.document, contents).to_xml
+        ""
+      end
 
-    def eref_parse(node, out)
-      linkend = node.children.reject { |c| %w{locality localityStack}.include? c.name }
-      relative = node["relative"] ||
-        node.at(ns(".//locality[@type = 'anchor']/referenceFrom"))&.text || ""
-      section = eref_clause(node.xpath(ns("./locality | ./localityStack")), nil) || ""
-      section = "" if relative.empty?
-      out.relref **attr_code(target: node["bibitemid"], section: section,
-                             relative: relative,
-                             displayFormat: node["displayFormat"]) do |l|
-                               linkend.each { |n| parse(n, l) }
-                             end
-    end
+      def eref_parse(node, out)
+        linkend = node.children.reject do |c|
+          %w{locality localityStack}.include? c.name
+        end
+        relative = node["relative"] ||
+          node.at(ns(".//locality[@type = 'anchor']/referenceFrom"))&.text || ""
+        section = eref_clause(node.xpath(ns("./locality | ./localityStack")),
+                              nil) || ""
+        #section = "" unless relative.empty?
+        out.relref **attr_code(target: node["bibitemid"], section: section,
+                               relative: relative,
+                               displayFormat: node["displayFormat"]) do |l|
+                                 linkend.each { |n| parse(n, l) }
+                               end
+      end
 
-    def eref_clause(refs, target)
-      ret = []
-      ret1 = ""
-      refs.each do |l|
-        if l.name == "localityStack"
-          ret << ret1
-          ret1 = ""
-          ret << eref_clause1(l.elements, target)
-        else
-          ret1 += eref_clause1([l], target)
+      def eref_clause(refs, target)
+        ret = []
+        ret1 = ""
+        refs.each do |l|
+          if l.name == "localityStack"
+            ret << ret1
+            ret1 = ""
+            ret << eref_clause1(l.elements, target)
+          else ret1 += eref_clause1([l], target)
+          end
         end
+        ret << ret1
+        ret.reject { |c| c.nil? || c.empty? }.join("; ")
       end
-      ret << ret1
-      ret.reject { |c| c.nil? || c.empty? }.join("; ")
-    end
 
-    def eref_clause1(refs, target)
-      refs.each do |l|
-        next unless %w(clause section).include? l["type"]
-        return l&.at(ns("./referenceFrom"))&.text
+      def eref_clause1(refs, _target)
+        refs.each do |l|
+          next unless %w(clause section).include? l["type"]
+
+          return l&.at(ns("./referenceFrom"))&.text
+        end
+        ""
       end
-      return ""
-    end
 
-    def index_parse(node, out)
-      out.iref nil, **attr_code(item: node.at(ns("./primary")).text, primary: node["primary"],
-                                subitem: node&.at(ns("./secondary"))&.text)
-    end
+      def index_parse(node, out)
+        out.iref nil, **attr_code(item: node.at(ns("./primary")).text,
+                                  primary: node["primary"],
+                                  subitem: node&.at(ns("./secondary"))&.text)
+      end
 
-    def bookmark_parse(node, out)
-      out.bookmark nil, **attr_code(anchor: node["id"])
+      def bookmark_parse(node, out)
+        out.bookmark nil, **attr_code(anchor: node["id"])
+      end
     end
   end
 end

data/lib/isodoc/ietf/references.rb

@@ -1,164 +1,188 @@
-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"])
+      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
+          docidentifier_render(bib, r)
         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]
+      end
+
+      def docidentifier_render(bib, out)
+        docidentifiers = bib.xpath(ns("./docidentifier"))
+        id = render_identifier(bibitem_ref_code(bib))
+        !id[1].nil? && id[1] != "(NO ID)" and out.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
+          u["type"] == "DOI" and
+            out.seriesInfo nil, **attr_code(value: u.text.sub(/^DOI /, ""),
+                                            name: "DOI")
+          u["type"] == "IETF" and docidentifier_ietf(u, out)
         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 docidentifier_ietf(ident, out)
+        if /^RFC /.match?(ident.text)
+          out.seriesInfo nil, **attr_code(value: ident.text.sub(/^RFC 0*/, ""),
+                                          name: "RFC")
+        elsif /^I-D\./.match?(ident.text)
+          out.seriesInfo nil, **attr_code(value: ident.text.sub(/^I-D\./, ""),
+                                          name: "Internet-Draft")
+        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 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_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_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
 
-    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_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
-    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_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
 
-      attr = date_attr(date&.at(ns("./on | ./from"))&.text) || return
-      f.date **attr_code(attr)
-    end
+      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
+
+      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/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",