metanorma-ietf 1.0.0

data/lib/asciidoctor/rfc/v3/converter.rb

@@ -0,0 +1,62 @@
+require "asciidoctor"
+
+require_relative "../common/base"
+require_relative "../common/front"
+require_relative "base"
+require_relative "blocks"
+require_relative "front"
+require_relative "inline_anchor"
+require_relative "lists"
+require_relative "table"
+require_relative "validate"
+
+module Asciidoctor
+  module Rfc::V3
+    # A {Converter} implementation that generates RFC XML output, a format used to
+    # format RFC proposals (https://tools.ietf.org/html/rfc7991)
+    #
+    # Features drawn from https://github.com/miekg/mmark/wiki/Syntax and
+    # https://github.com/riboseinc/rfc2md
+    class Converter
+      include ::Asciidoctor::Converter
+      include ::Asciidoctor::Writer
+
+      include ::Asciidoctor::Rfc::Common::Base
+      include ::Asciidoctor::Rfc::Common::Front
+      include ::Asciidoctor::Rfc::V3::Base
+      include ::Asciidoctor::Rfc::V3::Blocks
+      include ::Asciidoctor::Rfc::V3::Front
+      include ::Asciidoctor::Rfc::V3::InlineAnchor
+      include ::Asciidoctor::Rfc::V3::Lists
+      include ::Asciidoctor::Rfc::V3::Table
+      include ::Asciidoctor::Rfc::V3::Validate
+
+      register_for "rfc3"
+
+      $seen_back_matter = false
+      $xreftext = {}
+
+      def initialize(backend, opts)
+        super
+        # enable when Asciidoctor 1.5.7 is released
+        Asciidoctor::Compliance.natural_xrefs = false
+        # basebackend 'html'
+        outfilesuffix ".xml"
+      end
+
+      # alias_method :pass, :content
+      alias_method :embedded, :content
+      alias_method :audio, :skip
+      alias_method :colist, :skip
+      alias_method :page_break, :skip
+      alias_method :thematic_break, :skip
+      alias_method :video, :skip
+      alias_method :inline_button, :skip
+      alias_method :inline_kbd, :skip
+      alias_method :inline_menu, :skip
+      alias_method :inline_image, :skip
+
+      alias_method :inline_callout, :content
+    end
+  end
+end

data/lib/asciidoctor/rfc/v3/front.rb

@@ -0,0 +1,122 @@
+module Asciidoctor
+  module Rfc::V3
+    module Front
+      # Syntax:
+      #   = Title
+      #   Author
+      #   :METADATA
+      def front(node, xml)
+        xml.front do |xml_front|
+          title node, xml_front
+          series_info node, xml_front
+          author node, xml_front
+          date node, xml_front
+          area node, xml_front
+          workgroup node, xml_front
+          keyword node, xml_front
+        end
+      end
+
+      def series_info(node, xml)
+        docname = node.attr("name")
+        return if docname.nil? || docname&.empty?
+        is_rfc = docname =~ /^rfc-?/i || node.attr("doctype") == "rfc"
+
+        if is_rfc
+          name = docname.gsub(/^rfc-?/i, "") 
+          nameattr = "RFC" 
+        else
+          name = docname
+          nameattr = "Internet-Draft"
+        end
+        value = name.gsub(/\.[^\/]+$/, "")
+
+        seriesInfo_attributes = {
+          name: nameattr,
+          status: node.attr("status"),
+          stream: node.attr("submission-type") || "IETF",
+          value: value,
+        }
+        xml.seriesInfo **attr_code(seriesInfo_attributes)
+
+        intendedstatus = node.attr("intended-series")
+        if !is_rfc && !intendedstatus.nil?
+          unless intendedstatus =~ /^(standard|full-standard|bcp|fyi|informational|experimental|historic)$/
+            warn %(asciidoctor: WARNING (#{current_location(node)}): disallowed value for intended-series in document header: #{intendedstatus})
+          end
+          seriesInfo_attributes = {
+            name: "",
+            status: intendedstatus,
+            value: value,
+          }
+          xml.seriesInfo **attr_code(seriesInfo_attributes)
+        end
+
+        rfcstatus = intendedstatus
+        if is_rfc && !rfcstatus.nil?
+          m = /^(\S+) (\d+)$/.match rfcstatus
+          if m.nil?
+            rfcstatus = "exp" if rfcstatus == "experimental"
+            rfcstatus = "info" if rfcstatus == "informational"
+            warn %(asciidoctor: WARNING (#{current_location(node)}): disallowed value for intended-series in document header with no series number: #{rfcstatus}) unless rfcstatus =~ /^(info|exp|historic)$/
+          else
+            rfcstatus = m[1]
+            value = m[2]
+            warn %(asciidoctor: WARNING (#{current_location(node)}): disallowed value for intended-series in document header with series number: #{rfcstatus}) unless rfcstatus =~ /^(standard|full-standard|bcp)$/
+          end
+          seriesInfo_attributes = {
+            name: "",
+            status: rfcstatus,
+            value: value,
+          }
+          xml.seriesInfo **attr_code(seriesInfo_attributes)
+        end
+      end
+
+      def organization(node, suffix, xml)
+        organization = node.attr("organization#{suffix}")
+        xml.organization { |org| org << organization } unless organization.nil?
+      end
+
+      def address(node, suffix, xml)
+        email = node.attr("email#{suffix}")
+        facsimile = node.attr("fax#{suffix}")
+        phone = node.attr("phone#{suffix}")
+        postalline = node.attr("postal-line#{suffix}")
+        street = node.attr("street#{suffix}")
+        uri = node.attr("uri#{suffix}")
+        if [email, facsimile, phone, postalline, street, uri].any?
+          xml.address do |xml_address|
+            address1 node, suffix, xml_address if [postalline, street].any?
+            xml_address.phone { |p| p << phone } unless phone.nil?
+            xml_address.facsimile { |f| f << facsimile } unless facsimile.nil?
+            xml_address.email { |e| e << email } unless email.nil?
+            xml_address.uri { |u| u << uri } unless uri.nil?
+          end
+        end
+      end
+
+      private
+
+      def address1(node, suffix, xml_address)
+        postalline = node.attr("postal-line#{suffix}")
+        street = node.attr("street#{suffix}")
+        xml_address.postal do |xml_postal|
+          if postalline.nil?
+            city = node.attr("city#{suffix}")
+            code = node.attr("code#{suffix}")
+            country = node.attr("country#{suffix}")
+            region = node.attr("region#{suffix}")
+            street&.split("\\ ")&.each { |st| xml_postal.street { |s| s << st } }
+            xml_postal.city { |c| c << city } unless city.nil?
+            xml_postal.region { |r| r << region } unless region.nil?
+            xml_postal.code { |c| c << code } unless code.nil?
+            xml_postal.country { |c| c << country } unless country.nil?
+          else
+            postalline&.split("\\ ")&.each { |pl| xml_postal.postalLine { |p| p << pl } }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/rfc/v3/inline_anchor.rb

@@ -0,0 +1,89 @@
+module Asciidoctor
+  module Rfc::V3
+    module InlineAnchor
+      def inline_anchor(node)
+        case node.type
+        when :xref
+          inline_anchor_xref node
+        when :link
+          inline_anchor_link node
+        when :bibref
+          inline_anchor_bibref node
+        when :ref
+          inline_anchor_ref node
+        else
+          warn %(asciidoctor: WARNING (#{current_location(node)}): unknown anchor type: #{node.type.inspect})
+        end
+      end
+
+      private
+
+      def inline_anchor_xref(node)
+        text = node.text
+        if text =~ /^\S+ (of|comma|parens|bare)\b/
+          # <<crossreference#fragment,section (of|comma|parens|bare): text>> = relref
+          matched = /(?<section>\S+)\s+(?<format>[a-z]+)(: )?(?<text>.*)$/.match node.text
+
+          relref_contents = matched[:text]
+
+          relref_attributes = {
+            relative: node.attributes["path"].nil? ? nil : node.attributes["fragment"],
+            section: matched[:section],
+            displayFormat: matched[:format],
+            # fragment inserts file suffix, e.g. rfc2911#fragment becomes rfc2911.xml#fragment
+            target: node.target.gsub(/^#/, "").gsub(/(.)(\.xml)?#.*$/, "\\1"),
+          }
+
+          noko do |xml|
+            xml.relref relref_contents, **attr_code(relref_attributes)
+          end.join
+        else
+          xref_contents = node.text
+          matched = /^format=(?<format>counter|title|none|default)(?<text>:\s*.*)?$/.match xref_contents
+          xref_contents = if matched.nil?
+                            xref_contents
+                          else
+                            matched[:text].nil? ? "" : matched[:text].gsub(/^:\s*/, "")
+                          end
+
+          warn %(asciidoctor: WARNING (#{current_location(node)}): fragments not supported on crossreferences in v3 without relref: #{node.target} #{node.text}) if node.target =~ /.#/
+          xref_attributes = {
+            format: matched&.[](:format),
+            target: node.target.gsub(/^#/, "").gsub(/(.)(\.xml)?#.*$/, "\\1"),
+          }
+
+          noko do |xml|
+            xml.xref xref_contents, **attr_code(xref_attributes)
+          end.join
+        end
+      end
+
+      def inline_anchor_link(node)
+        eref_contents = node.target == node.text ? nil : node.text
+        eref_attributes = {
+          target: node.target,
+        }
+
+        noko do |xml|
+          xml.eref eref_contents, **attr_code(eref_attributes)
+        end.join
+      end
+
+      def inline_anchor_bibref(node)
+        unless node.xreftext.nil?
+          x = node.xreftext.gsub(/^\[(.+)\]$/, "\\1")
+          if node.id != x
+            $xreftext[node.id] = x
+          end
+        end
+        # NOTE technically node.text should be node.reftext, but subs have already been applied to text
+        # %(<bibanchor="#{node.id}">) # will convert to anchor attribute upstream
+        nil
+      end
+
+      def inline_anchor_ref(node)
+        warn %(asciidoctor: WARNING (#{current_location(node)}): anchor "#{node.id}" is not in a place where XML RFC will recognise it as an anchor attribute)
+      end
+    end
+  end
+end

data/lib/asciidoctor/rfc/v3/lists.rb

@@ -0,0 +1,176 @@
+module Asciidoctor
+  module Rfc::V3
+    module Lists
+      # Syntax:
+      #   * [[[ref1]]] A
+      #   * [[[ref2]]] B
+      #   * [[[ref3]]] (Referencegroup: no content)
+      #     * [[[ref4]]] C
+      #     * [[[ref4]]] D
+      # @note ulist repurposed as reference list
+      #      def reflist(node)
+      #        result = []
+      #        if node.context == :ulist
+      #          node.items.each do |item|
+      #            # we expect the biblio anchor to be right at the start of the reference
+      #            if item.blocks?
+      #              # we expect any list to be embedded, and only one level of embedding
+      #              # we expect no content in the referencegroup line other than the bibliographic anchor
+      #              result << "<referencegroup>#{item.text}".gsub(/<referencegroup>\s*\[?<bibanchor="([^"]+)">\]?.*$/, "<referencegroup anchor=\"\\1\">")
+      #              item.blocks.each { |b| result << reflist(b) }
+      #              result << "</referencegroup>"
+      #            else
+      #              # quoteTitle = get_header_attribute item, "quoteTitle"
+      #              # target = get_header_attribute item, "target"
+      #              # annotation = get_header_attribute item, "annotation"
+      #              # FIXME: [[[x]]] within embedded list is processed as [<bibref>]
+      #              result << "<reference>#{item.text}</refcontent></reference>".gsub(/<reference>\s*\[?<bibanchor="([^"]+)">\]?\s*/, "<reference anchor=\"\\1\"><refcontent>")
+      #            end
+      #          end
+      #        elsif node.context == :pass
+      #          # we expect raw xml
+      #          node.lines.each do |item|
+      #            # undo XML substitution
+      #            ref = item.gsub(/\&lt;/, "<").gsub(/\&gt;/, ">")
+      #            result << ref
+      #          end
+      #        else
+      #          warn %(asciidoctor: WARNING: references are not a ulist or raw XML: #{node.context})
+      #        end
+      #        result
+      #      end
+
+      # Syntax:
+      #   [[id]]
+      #   [empty=true,spacing=compact|normal] (optional)
+      #   * A
+      #   * B
+      def ulist(node)
+        result = []
+
+        result << noko do |xml|
+          ul_attributes = {
+            anchor: node.id,
+            empty: node.attr("empty"),
+            spacing: node.attr("spacing"),
+          }
+
+          xml.ul **attr_code(ul_attributes) do |xml_ul|
+            node.items.each do |item|
+              li_attributes = {
+                anchor: item.id,
+              }
+
+              xml_ul.li **attr_code(li_attributes) do |xml_li|
+                if item.blocks?
+                  xml_li.t do |t|
+                    t << item.text
+                  end
+                  xml_li << item.content
+                else
+                  xml_li << item.text
+                end
+              end
+            end
+          end
+        end
+
+        result
+      end
+
+      OLIST_TYPES = Hash.new("1").merge(
+        arabic:     "1",
+        # decimal:    "1", # not supported
+        loweralpha: "a",
+        # lowergreek: "lower-greek", # not supported
+        lowerroman: "i",
+        upperalpha: "A",
+        upperroman: "I",
+      ).freeze
+
+      # Syntax:
+      #   [[id]]
+      #   [start=n,group=n,spacing=normal|compact] (optional)
+      #   . A
+      #   . B
+      def olist(node)
+        result = []
+
+        result << noko do |xml|
+          type = OLIST_TYPES[node.style.to_sym]
+          type = node.attr("format") unless node.attr("format").nil?
+          ol_attributes = {
+            anchor: node.id,
+            start: node.attr("start"),
+            group: node.attr("group"),
+            type: type,
+            spacing: ("compact" if node.style == "compact") || node.attr("spacing"),
+          }
+
+          xml.ol **attr_code(ol_attributes) do |xml_ol|
+            node.items.each do |item|
+              li_attributes = {
+                anchor: item.id,
+              }
+              xml_ol.li **attr_code(li_attributes) do |xml_li|
+                if item.blocks?
+                  xml_li.t do |t|
+                    t << item.text
+                  end
+                  xml_li << item.content
+                else
+                  xml_li << item.text
+                end
+              end
+            end
+          end
+        end
+        result
+      end
+
+      # Syntax:
+      #   [[id]]
+      #   [horizontal,compact] (optional)
+      #   A:: B
+      #   C:: D
+      def dlist(node)
+        result = []
+
+        result << noko do |xml|
+          dl_attributes = {
+            anchor: node.id,
+            hanging: ("true" if node.style == "horizontal"),
+            spacing: ("compact" if node.style == "compact"),
+          }
+
+          xml.dl **attr_code(dl_attributes) do |xml_dl|
+            node.items.each do |terms, dd|
+              terms.each_with_index do |dt, idx|
+                xml_dl.dt { |xml_dt| xml_dt << dt.text }
+                if idx < terms.size - 1
+                  xml_dl.dd
+                end
+              end
+
+              if dd.nil?
+                xml_dl.dd
+              else
+                xml_dl.dd do |xml_dd|
+                  if dd.blocks?
+                    if dd.text?
+                      xml_dd.t { |t| t << dd.text }
+                    end
+                    xml_dd << dd.content
+                  else
+                    xml_dd << dd.text
+                  end
+                end
+              end
+            end
+          end
+        end
+        result
+      end
+    end
+  end
+end