metanorma-ietf 1.0.10 → 2.0.0

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

@@ -1,62 +0,0 @@
-require "asciidoctor"
-
-require_relative "../common/base"
-require_relative "../common/front"
-require_relative "../common/validate"
-require_relative "base"
-require_relative "blocks"
-require_relative "front"
-require_relative "inline_anchor"
-require_relative "lists"
-require_relative "table"
-
-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::Common::Validate
-      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
-
-      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

@@ -1,122 +0,0 @@
-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

@@ -1,89 +0,0 @@
-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

@@ -1,176 +0,0 @@
-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