metanorma-ietf 1.0.0

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

@@ -0,0 +1,329 @@
+# coding: utf-8
+
+module Asciidoctor
+  module Rfc::V3
+    module Base
+      # Syntax:
+      #   =Title
+      #   Author
+      #   :ipr
+      #   :obsoletes
+      #   :updates
+      #   :submissionType
+      #   :indexInclude
+      #   :iprExtract
+      #   :sortRefs
+      #   :symRefs
+      #   :tocInclude
+      #   :tocDepth
+      #
+      #   ABSTRACT
+      #
+      #   NOTEs
+      #
+      #   ==first title
+      #   CONTENT
+      #
+      #   [bibliography] # start of back matter
+      #   == Bibliography
+      #
+      #   [appendix] # start of back matter if not already started
+      #   == Appendix
+      def document(node)
+        $seen_back_matter = false
+        # If this is present, then BCP14 keywords in boldface are not assumed to be <bcp14> tags. By default they are.
+        $bcp_bold = !(node.attr? "no-rfc-bold-bcp14")
+        $smart_quotes = (node.attr("smart-quotes") != "false")
+        $xreftext = {}
+        result = []
+        result << '<?xml version="1.0" encoding="UTF-8"?>'
+
+        t = Time.now.getutc
+        preptime = sprintf(
+          "%04d-%02d-%02dT%02d:%02d:%02dZ",
+          t.year, t.month, t.day, t.hour, t.min, t.sec
+        )
+
+        rfc_attributes = {
+          ipr:            node.attr("ipr"),
+          obsoletes:      node.attr("obsoletes"),
+          updates:        node.attr("updates"),
+          indexInclude:   node.attr("index-include"),
+          iprExtract:     node.attr("ipr-extract"),
+          sortRefs:       node.attr("sort-refs"),
+          symRefs:        node.attr("sym-refs"),
+          tocInclude:     node.attr("toc-include"),
+          tocDepth:       node.attr("toc-depth"),
+          submissionType: node.attr("submission-type") || "IETF",
+          'xml:lang':     node.attr("xml-lang"),
+          prepTime:       preptime,
+          version:        "3",
+          'xmlns:xi':        "http://www.w3.org/2001/XInclude",
+        }
+
+        rfc_open = noko { |xml| xml.rfc **attr_code(rfc_attributes) }.join.gsub(/\/>$/, ">")
+        result << rfc_open
+
+        result << (link node)
+
+        result << noko { |xml| front node, xml }
+        result.last.last.gsub! /<\/front>$/, "" # FIXME: this is a hack!
+        result << "</front><middle1>"
+
+        result << node.content if node.blocks?
+        result << ($seen_back_matter ? "</back>" : "</middle>")
+        result << "</rfc>"
+
+        # <middle> needs to move after preamble
+        result = result.flatten
+        result = if result.any? { |e| e =~ /<\/front><middle>/ } && result.any? { |e| e =~ /<\/front><middle1>/ }
+                   result.reject { |e| e =~ /<\/front><middle1>/ }
+                 else
+                   result.map { |e| e =~ /<\/front><middle1>/ ? "</front><middle>" : e }
+                 end
+        ret = result * "\n"
+        ret = cleanup(ret)
+        ret1 = Nokogiri::XML(ret)
+        ret1 = set_pis(node, ret1)
+        ret1 = insert_biblio(node, ret1) unless node.attr("biblio-dir").nil? || node.attr("biblio-dir").empty?
+        Validate::validate(ret1)
+        ret1 = resolve_references(node, ret1)
+        # Validate::validate(ret1)
+        ret1.to_xml
+      end
+
+      def resolve_references(node, doc)
+        extract_entities(node, doc).each do |entity|
+          # TODO actual XML
+          entity[:node].replace("<xi:include href='#{entity[:url]}' parse='text'/>")
+        end
+        doc
+      end
+
+      # Syntax:
+      #   = Title
+      #   Author
+      #   :link href,href rel
+      def link(node)
+        result = []
+        result << noko do |xml|
+          links = (node.attr("link") || "").split(/,\s*/)
+          links.each do |link|
+            matched = /^(?<href>\S+)\s+(?<rel>\S+)$/.match link
+            link_attributes = {
+              href: matched.nil? ? link : matched[:href],
+              rel: matched.nil? ? nil : matched[:rel],
+            }
+            xml.link **attr_code(link_attributes)
+          end
+        end
+        result
+      end
+
+      def inline_break(node)
+        # <br> is only defined within tables
+        noko do |xml|
+          xml << node.text
+          xml.br if node.parent.context == :cell
+        end.join
+      end
+
+      BCP_KEYWORDS = [
+        "MUST", "MUST NOT", "REQUIRED", "SHALL", "SHALL NOT",
+        "SHOULD", "SHOULD NOT", "RECOMMENDED", "MAY", "OPTIONAL"
+      ].freeze
+
+      def inline_quoted(node)
+        noko do |xml|
+          case node.type
+          when :emphasis then xml.em node.text
+          when :strong
+            if $bcp_bold && BCP_KEYWORDS.include?(node.text)
+              xml.bcp14 node.text
+            else
+              xml.strong node.text
+            end
+          when :monospaced then xml.tt node.text
+          when :double
+            xml << ($smart_quotes ? "“#{node.text}”" : "\"#{node.text}\"")
+          when :single
+            xml << ($smart_quotes ? "‘#{node.text}’" : "'#{node.text}'")
+          when :superscript then xml.sup node.text
+          when :subscript then xml.sub node.text
+          else
+            # [bcp14]#MUST NOT#
+            if node.role == "bcp14"
+              xml.bcp14 node.text.upcase
+            elsif node.role == "comment"
+              xml.comment " " + node.text + " "
+            else
+              xml << node.text
+            end
+          end
+        end.join
+      end
+
+      # Syntax:
+      #   [[id]]
+      #   [keepWithNext=true,keepWithPrevious=true] (optional)
+      #   Text
+      def paragraph(node)
+        if node.role == "comment"
+          return noko do |xml|
+            xml.comment " " + [flatten_rawtext(node)].flatten.join("\n") + " "
+          end.join("\n")
+        end
+
+        t_attributes = {
+          anchor: node.id,
+          keepWithNext: node.attr("keep-with-next"),
+          keepWithPrevious: node.attr("keep-with-previous"),
+        }
+        return noko do |xml|
+          xml.t **attr_code(t_attributes) do |xml_t|
+            xml_t << node.content
+          end
+        end.join("\n")
+      end
+
+      def ref_section(node)
+        result = []
+        $processing_reflist = true
+        references_attributes = {
+          anchor: node.id,
+        }
+
+        if node.blocks.empty?
+          result << noko do |xml|
+            xml.references **references_attributes do |xml_references|
+              xml_references.name node.title unless node.title.nil?
+            end
+          end
+        end
+        node.blocks.each do |block|
+          if block.context == :section
+            result << section(block)
+          elsif block.context == :pass
+            # we are assuming a single contiguous :pass block of XML
+            result << noko do |xml|
+              xml.references **references_attributes do |xml_references|
+                xml_references.name node.title unless node.title.nil?
+                # xml_references << reflist(block).join("\n")
+                # NOTE: we're allowing the user to do more or less whathever
+                #   in the passthrough since the xpath below just fishes out ALL
+                #   <reference>s in an unrooted fragment, regardless of structure.
+                Nokogiri::XML::DocumentFragment.
+                  parse(block.content).xpath(".//reference").
+                  each { |reference| xml_references << reference.to_xml }
+              end
+            end
+          elsif block.context == :ulist
+            block.items.each(&:text)
+            # we only process the item for its displayreferences
+          end
+        end
+
+        unless $xreftext.empty? || $seen_back_matter
+          result = result.unshift($xreftext.keys.map { |k| %(<displayreference target="#{k}" to="#{$xreftext[k]}"/>) })
+        end
+        result = result.unshift("</middle><back>") unless $seen_back_matter
+        $processing_reflist = false
+        $seen_back_matter = true
+        result
+      end
+
+      # Syntax:
+      #   :sectnums: (toggle)
+      #   :sectnums!: (toggle)
+      #   [[id]]
+      #   [removeInRFC=true,toc=include|exclude|default] (optional)
+      #   == title
+      #   Content
+      #
+      #   [[id]]
+      #   [bibliography]
+      #   == Normative|Informative References
+      #   * [[[ref1]]] Ref [must provide references as list]
+      #   * [[[ref2]]] Ref
+      def section(node)
+        if node.attr("style") == "bibliography" ||
+            node.parent.context == :section && node.parent.attr("style") == "bibliography"
+          result = ref_section(node)
+        else
+          result = []
+          if node.attr("style") == "appendix"
+            result << "</middle><back>" unless $seen_back_matter
+            $seen_back_matter = true
+          end
+
+          section_attributes = {
+            anchor: node.id,
+            removeInRFC: node.attr("remove-in-rfc"),
+            toc: node.attr("toc"),
+            numbered: node.attr?("sectnums"),
+          }
+
+          result << noko do |xml|
+            xml.section **attr_code(section_attributes) do |section_xml|
+              section_xml.name { |name| name << node.title } unless node.title.nil?
+              section_xml << node.content
+            end
+          end
+        end
+        result
+      end
+
+      # Syntax:
+      #   [[id]]
+      #   .Name
+      #   [link=xxx,align=left|center|right,alt=alt_text,type]
+      #   image::filename[alt,width,height]
+      # @note ignoring width, height attributes
+      def image(node)
+        uri = node.image_uri node.attr("target")
+        artwork_attributes = {
+          align: node.attr("align"),
+          alt: node.alt,
+          anchor: node.id,
+          height: node.attr("height"),
+          name: node.title,
+          src: uri,
+          type: (uri =~ /\.svg$/ ? "svg" : "binary-art"),
+          width: node.attr("width"),
+        }
+
+        noko do |xml|
+          if node.parent.context != :example
+            xml.figure do |xml_figure|
+              xml_figure.artwork **attr_code(artwork_attributes)
+            end
+          else
+            xml.artwork **attr_code(artwork_attributes)
+          end
+        end
+      end
+
+      # clean up XML
+      def cleanup(doc)
+        xmldoc = Nokogiri::XML(doc)
+        crefs = xmldoc.xpath("//cref")
+        # any crefs that are direct children of section should become children of the preceding
+        # paragraph, if it exists; otherwise, they need to be wrapped in a paragraph
+        crefs.each do |cref|
+          if cref.parent.name == "section"
+            prev = cref.previous_element
+            if !prev.nil? && prev.name == "t"
+              cref.parent = prev
+            else
+              t = Nokogiri::XML::Element.new("t", xmldoc)
+              cref.before(t)
+              cref.parent = t
+            end
+          end
+        end
+        xmldoc = smart_quote_cleanup(xmldoc) unless $smart_quotes
+        xmldoc.to_xml(encoding: "US-ASCII")
+      end
+    end
+  end
+end

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

@@ -0,0 +1,246 @@
+require "htmlentities"
+require "uri"
+
+module Asciidoctor
+  module Rfc::V3
+    module Blocks
+      # Syntax:
+      # [discrete]
+      # == Section
+      def floating_title(node)
+        noko do |xml|
+          xml.t { |xml_t| xml_t.strong node.title }
+        end
+      end
+
+      # Syntax:
+      #   [[id]]
+      #   .name
+      #   [align=left|center|right,alt=alt_text] (optional)
+      #   ....
+      #     literal
+      #   ....
+      def literal(node)
+        artwork_attributes = {
+          anchor: node.id,
+          align: node.attr("align"),
+          type: "ascii-art",
+          name: node.title,
+          alt: node.attr("alt"),
+        }
+
+        # NOTE: html escaping is performed by Nokogiri
+        artwork_content = "\n" + node.lines.join("\n") + "\n"
+
+        noko do |xml|
+          if node.parent.context != :example
+            xml.figure 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
+      end
+
+      # stem is treated as literal, but with center alignment
+      def stem(node)
+        artwork_attributes = {
+          anchor: node.id,
+          align: node.attr("align") || "center",
+          type: "ascii-art",
+          name: node.title,
+          alt: node.attr("alt"),
+        }
+
+        # NOTE: html escaping is performed by Nokogiri
+        artwork_content = "\n" + node.lines.join("\n") + "\n"
+
+        noko do |xml|
+          if node.parent.context != :example
+            xml.figure 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
+      end
+
+      # Syntax:
+      #   [[id]]
+      #   [quote, attribution, citation info] # citation info limited to URL
+      #   Text
+      def quote(node)
+        cite_value = node.attr("citetitle")
+        cite_value = nil unless cite_value.to_s =~ URI::DEFAULT_PARSER.make_regexp
+
+        blockquote_attributes = {
+          anchor: node.id,
+          quotedFrom: node.attr("attribution"),
+          cite: cite_value,
+        }
+
+        noko do |xml|
+          xml.blockquote **attr_code(blockquote_attributes) do |xml_blockquote|
+            xml_blockquote << node.content
+          end
+        end
+      end
+
+      # realise as quote() ; <br/> in v3 does not have the applicability of <vspace/>,
+      # it is restricted to tables
+      def verse(node)
+        quote(node)
+      end
+
+      # Syntax:
+      #   = Title
+      #   Author
+      #   :HEADER
+      #
+      #   ABSTRACT
+      #
+      #   NOTE: note
+      #
+      #   [NOTE]
+      #   .Title (in preamble)
+      #   ====
+      #     Content
+      #   ====
+      #
+      #     [NOTE,removeInRFC=true] (in preamble)
+      #     [NOTE,display=true|false,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 = {
+            removeInRFC: node.attr("remove-in-rfc"),
+          }
+
+          result << noko do |xml|
+            xml.note **attr_code(note_attributes) do |xml_note|
+              xml_note.name node.title unless node.title.nil?
+              xml_note << HTMLEntities.new.decode([paragraph1(node)].flatten.join("\n"))
+            end
+          end
+        else
+          cref_attributes = {
+            anchor: node.id,
+            display: node.attr("display"),
+            source: node.attr("source"),
+          }
+
+          cref_contents = node.blocks? ? flatten(node) : node.content
+          cref_contents = [cref_contents].flatten.join("\n")
+          warn <<~WARNING_MESSAGE if node.blocks?
+            asciidoctor: WARNING (#{current_location(node)}): comment can not contain blocks of text in XML RFC:\n #{node.content}
+          WARNING_MESSAGE
+
+          result << noko do |xml|
+            xml.cref **attr_code(cref_attributes) do |xml_cref|
+              xml_cref << cref_contents
+            end
+          end
+        end
+        result
+      end
+
+      # Syntax:
+      #   [[id]]
+      #   ****
+      #   Sidebar
+      #   ****
+      def sidebar(node)
+        aside_attributes = {
+          anchor: node.id,
+        }
+        noko do |xml|
+          xml.aside **attr_code(aside_attributes) do |xml_aside|
+            xml_aside << node.content
+          end
+        end
+      end
+
+      # Syntax:
+      #   .Title
+      #   ====
+      #   Example
+      #   ====
+      def example(node)
+        node.blocks.each do |b|
+          unless %i{listing image literal stem}.include? b.context
+            warn "asciidoctor: WARNING (#{current_location(b)}): examples (figures) should only contain listings (sourcecode), images (artwork), or literal (artwork):\n#{b.lines}"
+          end
+        end
+
+        figure_attributes = {
+          anchor: node.id,
+        }
+
+        noko do |xml|
+          xml.figure **attr_code(figure_attributes) do |xml_figure|
+            xml_figure.name node.title if node.title?
+            # TODO iref
+            xml_figure << node.content
+          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 = {
+          anchor: node.id,
+          align: nil,
+          alt: nil,
+          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
+            xml.figure do |xml_figure|
+              # xml_figure.sourcecode sourcecode_content, **attr_code(sourcecode_attributes)
+              xml_figure.sourcecode **attr_code(sourcecode_attributes) do |a|
+                a.cdata sourcecode_content
+              end
+            end
+          else
+            # xml.sourcecode sourcecode_content, **attr_code(sourcecode_attributes)
+            xml.sourcecode **attr_code(sourcecode_attributes) do |a|
+              a.cdata sourcecode_content
+            end
+          end
+        end
+      end
+    end
+  end
+end