metanorma-ietf 1.0.10 → 2.0.0

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

@@ -1,299 +0,0 @@
-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
-
-      def pass(node)
-        node.content
-      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.
-      # UPDATE 20190517
-      # @note admonitions within preamble are notes. Elsewhere, they are LABEL followed by text
-      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
-=begin
-          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
-=end
-          result << "<t>#{node.attr("name").upcase}</t>"
-          if node.blocks?
-            node.blocks.each do |b|
-              result << send(b.context, b)
-            end
-          else
-            result << paragraph(node)
-          end
-        end
-        result
-      end
-
-      # is this a text-only example? if so, mark it up as paragraphs
-      def text_only_example(node)
-        seen_artwork = false
-        node.blocks.each do |b|
-          case b.context
-          when :listing, :image, :literal, :stem
-            seen_artwork = true
-          end
-        end
-        !seen_artwork
-      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
-
-        if text_only_example(node)
-          noko do |xml|
-            node.blocks.each do |b|
-              xml << node.content
-            end
-          end
-        else
-          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 << Array(b.content).join("\n")
-                    end
-                  else
-                    xml_figure.preamble do |preamble|
-                      preamble << Array(b.content).join("\n")
-                    end
-                  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

@@ -1,60 +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::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::Common::Validate
-      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
-
-      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

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

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