metanorma-ietf 1.0.0

data/lib/asciidoctor/rfc/v2/blocks.rb

@@ -0,0 +1,261 @@
+require "htmlentities"
+
+module Asciidoctor
+  module Rfc::V2
+    module Blocks
+      # Syntax:
+      # [discrete]
+      # == Section
+      def floating_title(node)
+        noko do |xml|
+          xml.t do |xml_t|
+            xml_t.spanx node.title, style: "strong"
+          end
+        end
+      end
+
+      # Syntax:
+      #   [[id]]
+      #   .Name
+      #   [align=left|center|right,alt=alt_text,type] (optional)
+      #   ....
+      #     literal
+      #   ....
+      def literal(node)
+        artwork_attributes = {
+          align: node.attr("align"),
+          type: node.attr("type"),
+          name: node.title,
+          alt: node.attr("alt"),
+        }
+
+        # NOTE: html escaping is performed by Nokogiri
+        artwork_content = "\n" +  node.lines.join("\n") + "\n"
+
+        ret = noko do |xml|
+          if node.parent.context != :example
+            figure_attributes = {
+              anchor: node.id,
+            }
+            xml.figure **attr_code(figure_attributes) do |xml_figure|
+              # xml_figure.artwork artwork_content, **attr_code(artwork_attributes)
+              xml_figure.artwork **attr_code(artwork_attributes) do |a|
+                a.cdata artwork_content
+              end
+            end
+          else
+            # xml.artwork artwork_content, **attr_code(artwork_attributes)
+            xml.artwork **attr_code(artwork_attributes) do |a|
+              a.cdata artwork_content
+            end
+          end
+        end
+        ret
+      end
+
+      # stem is treated as literal, but with center alignment
+      def stem(node)
+        artwork_attributes = {
+          align: node.attr("align") || "center",
+          type: node.attr("type"),
+          name: node.title,
+          alt: node.attr("alt"),
+        }
+
+        # NOTE: html escaping is performed by Nokogiri
+        artwork_content = "\n" +  node.lines.join("\n") + "\n"
+
+        ret = noko do |xml|
+          if node.parent.context != :example
+            figure_attributes = {
+              anchor: node.id,
+            }
+            xml.figure **attr_code(figure_attributes) do |xml_figure|
+              # xml_figure.artwork artwork_content, **attr_code(artwork_attributes)
+              xml_figure.artwork **attr_code(artwork_attributes) do |a|
+                a.cdata artwork_content
+              end
+            end
+          else
+            # xml.artwork artwork_content, **attr_code(artwork_attributes)
+            xml.artwork **attr_code(artwork_attributes) do |a|
+              a.cdata artwork_content
+            end
+          end
+        end
+        ret
+      end
+
+      # Syntax:
+      #   = Title
+      #   Author
+      #   :HEADER
+      #
+      #   ABSTRACT
+      #
+      #   NOTE: note
+      #
+      #   [NOTE]
+      #   .Title (in preamble)
+      #   ====
+      #     Content
+      #   ====
+      #
+      #     [NOTE] (in preamble)
+      #     [NOTE,source=name] (in body)
+      #   .Title
+      #   ====
+      #     Content
+      #   ====
+      #
+      # @note admonitions within preamble are notes. Elsewhere, they are comments.
+      def admonition(node)
+        result = []
+        if node.parent.context == :preamble
+          note_attributes = {
+            # default title provided: title is mandatory
+            title: (node.title.nil? ? "NOTE" : node.title),
+          }
+
+          note_contents = HTMLEntities.new.decode([paragraph1(node)].flatten.join("\n"))
+
+          result << noko do |xml|
+            xml.note **attr_code(note_attributes) do |xml_note|
+              xml_note << note_contents
+            end
+          end
+        else
+          cref_attributes = {
+            anchor: node.id,
+            source: node.attr("source"),
+          }
+
+          # remove all formatting: cref content is pure text
+          cref_contents = flatten_rawtext(node)
+          cref_contents = [cref_contents].flatten.join("\n")
+          warn <<~WARNING_MESSAGE if node.blocks?
+            asciidoctor: WARNING (#{node.lineno}): comment can not contain blocks of text in XML RFC:\n #{node.content}
+          WARNING_MESSAGE
+
+          result << noko do |xml|
+            if node.parent.context !~ /table|example|paragraph|section/
+              xml.t do |xml_t|
+                xml_t.cref **attr_code(cref_attributes) do |xml_cref|
+                  xml_cref << cref_contents
+                end
+              end
+            else
+              xml.cref **attr_code(cref_attributes) do |xml_cref|
+                xml_cref << cref_contents
+              end
+            end
+          end
+        end
+        result
+      end
+
+      # Syntax:
+      #   [[id]]
+      #   .Title
+      #   [align,alt,suppress-title]
+      #   ====
+      #   Example
+      #   ====
+      def example(node)
+        figure_attributes = {
+          anchor: node.id,
+          align: node.attr("align"),
+          alt: node.alt,
+          title: node.title,
+          'suppress-title': node.attr("suppress-title"),
+          # TODO: is 'suppress-title' the correct attribute name?
+        }
+        # TODO iref
+        seen_artwork = false
+        noko do |xml|
+          xml.figure **attr_code(figure_attributes) do |xml_figure|
+            node.blocks.each do |b|
+              case b.context
+              when :listing, :image, :literal, :stem
+                xml_figure << send(b.context, b).join("\n")
+                seen_artwork = true
+              else
+                # we want to see the para text, not its <t> container
+                if seen_artwork
+                  xml_figure.postamble do |postamble|
+                    postamble << b.content
+                  end
+                else
+                  xml_figure.preamble do |preamble|
+                    preamble << b.content
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+
+      # Syntax:
+      #   .name
+      #   [source,type,src=uri] (src is mutually exclusive with listing content) (v3)
+      #   [source,type,src=uri,align,alt] (src is mutually exclusive with listing content) (v2)
+      #   ----
+      #   code
+      #   ----
+      def listing(node)
+        sourcecode_attributes = {
+          align: node.attr("align"),
+          alt: node.alt,
+          name: node.title,
+          type: node.attr("language"),
+          src: node.attr("src"),
+        }
+
+        # NOTE: html escaping is performed by Nokogiri
+        sourcecode_content =
+          sourcecode_attributes[:src].nil? ? "\n" + node.lines.join("\n") + "\n" : ""
+
+        noko do |xml|
+          if node.parent.context != :example
+            figure_attributes = {
+              anchor: node.id,
+            }
+            xml.figure **attr_code(figure_attributes) do |xml_figure|
+              # xml_figure.artwork sourcecode_content, **attr_code(sourcecode_attributes)
+              xml_figure.artwork **attr_code(sourcecode_attributes) do |a|
+                a.cdata sourcecode_content
+              end
+
+            end
+          else
+            # xml.artwork sourcecode_content, **attr_code(sourcecode_attributes)
+            xml.artwork **attr_code(sourcecode_attributes) do |a|
+              a.cdata sourcecode_content
+            end
+          end
+        end
+      end
+
+      def quote(node)
+        result = []
+        if node.blocks?
+          node.blocks.each do |b|
+            result << send(b.context, b)
+          end
+        else
+          result = paragraph(node)
+        end
+        if node.attr("citetitle") || node.attr("attribution")
+          cite = node.attr("attribution") || ""
+          cite += ", " if node.attr("citetitle") && node.attr("attribution")
+          cite += (node.attr("citetitle") || "")
+          cite = "-- " + cite
+          result << "<t>#{cite}</t>"
+        end
+        result
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+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::V2
+    # A {Converter} implementation that generates RFC XML 2 output, a format used to
+    # format RFC proposals (https://tools.ietf.org/html/rfc7749)
+    #
+    # 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::V2::Base
+      include ::Asciidoctor::Rfc::V2::Blocks
+      include ::Asciidoctor::Rfc::V2::Front
+      include ::Asciidoctor::Rfc::V2::InlineAnchor
+      include ::Asciidoctor::Rfc::V2::Lists
+      include ::Asciidoctor::Rfc::V2::Table
+      include ::Asciidoctor::Rfc::V2::Validate
+
+      register_for "rfc2"
+
+      $seen_back_matter = false
+      $xreftext = {}
+
+      def initialize(backend, opts)
+        super
+        Asciidoctor::Compliance.natural_xrefs = false
+        basebackend "html"
+        outfilesuffix ".xml"
+      end
+
+      # alias_method :pass, :content
+      alias_method :embedded, :content
+      alias_method :sidebar, :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
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+module Asciidoctor
+  module Rfc::V2
+    module Front
+      # Syntax:
+      #   = Title
+      #   Author
+      #   :METADATA
+      def front(node, xml)
+        xml.front do |xml_front|
+          title 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 organization(node, suffix, xml)
+        organization = node.attr("organization#{suffix}")
+        organization_abbrev = node.attr("organization_abbrev#{suffix}")
+        organization_attributes = {
+          abbrev: organization_abbrev,
+        }
+        unless organization.nil?
+          xml.organization **attr_code(organization_attributes) do |org|
+            org << organization
+          end
+        end
+      end
+
+      def address(node, suffix, xml)
+        email = node.attr("email#{suffix}")
+        facsimile = node.attr("fax#{suffix}")
+        phone = node.attr("phone#{suffix}")
+        street = node.attr("street#{suffix}")
+        uri = node.attr("uri#{suffix}")
+
+        # If there is no provided elements for address, don't show it
+        return unless [email, facsimile, phone, street, uri].any?
+
+        # https://tools.ietf.org/html/rfc7749#section-2.27
+        # Note that at least one <street> element needs to be present;
+        # however, formatters will handle empty values just fine.
+        street = street ? street.split("\\ ") : [""]
+
+        xml.address do |xml_address|
+          xml_address.postal do |xml_postal|
+            city = node.attr("city#{suffix}")
+            code = node.attr("code#{suffix}")
+            country = node.attr("country#{suffix}")
+            region = node.attr("region#{suffix}")
+
+            street.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?
+          end
+
+          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
+  end
+end

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

@@ -0,0 +1,111 @@
+module Asciidoctor
+  module Rfc::V2
+    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)
+        if node.text =~ /^\S+ (of|comma|parens|bare)\b/
+          # <<crossreference#fragment,section (of|comma|parens|bare): text>> = relref:
+          # render equivalent in v2
+          matched = /(?<section>\S+)\s+(?<format>[a-z]+)(: )?(?<text>.*)$/.match node.text
+
+          # fragment inserts file suffix, e.g. rfc2911#fragment becomes rfc2911.xml#fragment
+          target = node.target.gsub(/^#/, "").gsub(/(.)(\.xml)?#.*$/, "\\1")
+          # reftarget = target
+          warn %(asciidoctor: WARNING (#{current_location(node)}): fragments not supported on crossreferences in v2: #{node.target} #{node.text}) if node.target =~ /.#/
+          # reftarget = "#{target}##{node.attributes['fragment']}" unless node.attributes["path"].nil?
+
+          xref_contents = ""
+          case matched[:format]
+          when "of"
+            prefix = "Section #{matched[:section]} of "
+          when "comma"
+            suffix = ", Section #{matched[:section]}"
+          when "parens"
+            suffix = " (Section #{matched[:section]})"
+          when "bare"
+            xref_contents = matched[:section]
+          end
+          unless matched[:text].empty?
+            xref_contents = if xref_contents.empty?
+                              matched[:text].to_s
+                            else
+                              "#{xref_contents}: #{matched[:text]}"
+                            end
+          end
+
+          xref_attributes = {
+            target: target,
+          }.reject { |_, value| value.nil? }
+
+        else
+
+          matched = /^format=(?<format>counter|title|none|default)(?<text>:\s*.*)?$/.match node.text
+          xref_contents = if matched.nil?
+                            node.text
+                          else
+                            matched[:text].nil? ? "" : matched[:text].gsub(/^:\s*/, "")
+                          end
+          matched ||= {}
+
+          warn %(asciidoctor: WARNING (#{current_location(node)}): fragments not supported on crossreferences in v2: #{node.target} #{node.text}) if node.target =~ /.#/
+          xref_attributes = {
+            # fragment inserts file suffix, e.g. rfc2911#fragment becomes rfc2911.xml#fragment
+            target: node.target.gsub(/^#/, "").gsub(/(.)(\.xml)?#.*$/, "\\1"),
+            format: matched[:format],
+            align: node.attr("align"),
+          }
+        end
+
+        noko do |xml|
+          xml << prefix unless prefix.nil? || prefix.empty?
+          xml.xref xref_contents, **attr_code(xref_attributes)
+          xml << suffix unless suffix.nil? || suffix.empty?
+        end.join
+      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