metanorma-ietf 1.0.0

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

@@ -0,0 +1,120 @@
+module Asciidoctor
+  module Rfc::Common
+    module Front
+      def title(node, xml)
+        title_attributes = {
+          abbrev: node.attr("abbrev"),
+        }
+        xml.title **attr_code(title_attributes) do |t|
+          t << node.doctitle
+        end
+      end
+
+      # Syntax:
+      #   = Title
+      #   Author;Author_2;Author_3
+      #   :fullname
+      #   :lastname
+      #   :organization
+      #   :email
+      #   :fullname_2
+      #   :lastname_2
+      #   :organization_2
+      #   :email_2
+      #   :fullname_3
+      #   :lastname_3
+      #   :organization_3
+      #   :email_3
+      # @note recurse: author, author_2, author_3...
+      def author(node, xml)
+        author1(node, "", xml)
+        i = 2
+        loop do
+          suffix = "_#{i}"
+          author = node.attr("author#{suffix}")
+          fullname = node.attr("fullname#{suffix}")
+          break unless [author, fullname].any?
+          author1(node, suffix, xml)
+          i += 1
+        end
+      end
+
+      # Syntax:
+      #   = Title
+      #   Author (contains author firstname lastname middlename authorinitials email: Firstname Middlename Lastname <Email>)
+      #   :fullname
+      #   :lastname
+      #   :forename_initials (excludes surname, unlike Asciidoc "initials" attribute)
+      #   :organization
+      #   :email
+      #   :role
+      #   :fax
+      #   :uri
+      #   :phone
+      #   :postalLine (mutually exclusive with street city etc) (lines broken up by "\ ")
+      #   :street
+      #   :city
+      #   :region
+      #   :country
+      #   :code
+      def author1(node, suffix, xml)
+        role = node.attr("role#{suffix}")
+        role = nil if role == "author"
+        author_attributes = {
+          fullname: node.attr("author#{suffix}") || node.attr("fullname#{suffix}"),
+          surname: node.attr("lastname#{suffix}"),
+          initials: node.attr("forename_initials#{suffix}"),
+          role: role,
+        }
+
+        xml.author **attr_code(author_attributes) do |xml_sub|
+          organization node, suffix, xml_sub
+          address node, suffix, xml_sub
+        end
+      end
+
+      def date1(revdate, xml)
+        revdate.gsub!(/T.*$/, "")
+        if revdate.length == 4 && revdate =~ /^\d\d\d\d$/
+          date_attributes = {
+            year: revdate,
+          }
+        elsif revdate =~ /^\d\d\d\d-?\d\d$/
+          matched = /^(?<year>\d\d\d\d)-(?<month>\d\d)$/.match revdate
+          date_attributes = {
+            month: Date::MONTHNAMES[(matched[:month]).to_i],
+            year: matched[:year],
+          }
+        else
+          d = Date.iso8601 revdate
+          date_attributes = {
+            day: d.day.to_s.gsub(/^0/, ""),
+            month: Date::MONTHNAMES[d.month],
+            year: d.year,
+          }
+        end
+        xml.date **attr_code(date_attributes)
+      end
+
+      # Syntax:
+      #   = Title
+      #   Author
+      #   :revdate or :date
+      def date(node, xml)
+        revdate = node.attr("revdate") || node.attr("date")
+        if revdate.nil?
+          revdate = DateTime.now.iso8601
+          warn %(asciidoctor: WARNING (#{current_location(node)}): revdate attribute missing from header, provided current date)
+        end
+        unless revdate.nil?
+          begin
+            date1(revdate, xml)
+          rescue ArgumentError # invalid date
+            warn %(asciidoctor: WARNING (#{current_location(node)}): invalid date in header, provided current date)
+            date1(DateTime.now.iso8601, xml)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,379 @@
+require "pp"
+# coding: utf-8
+module Asciidoctor
+  module Rfc::V2
+    module Base
+      # Syntax:
+      #   =Title
+      #   Author
+      #   :status
+      #   :consensus
+      #   :name
+      #   :number
+      #
+      #   :ipr
+      #   :obsoletes
+      #   :updates
+      #   :submissionType
+      #   :indexInclude
+      #   :ipr-extract
+      #   :sort-refs
+      #   :sym-refs
+      #   :toc-include
+      #
+      #   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
+        $smart_quotes = (node.attr("smart-quotes") != "false")
+        $inline_definition_lists = (node.attr("inline-definition-lists") == "true")
+
+        result = []
+        result << '<?xml version="1.0" encoding="UTF-8"?>'
+
+        is_rfc = node.attr("doctype") == "rfc"
+
+        consensus_value = {
+          "false" => "no",
+          "true" => "yes",
+        }[node.attr("consensus")] || node.attr("consensus")
+
+        category = node.attr("status")
+        category = "info" if category == "informational"
+        category = "std" if category == "standard"
+        category = "exp" if category == "experimental"
+
+        rfc_attributes = {
+          ipr:            node.attr("ipr"),
+          obsoletes:      node.attr("obsoletes"),
+          updates:        node.attr("updates"),
+          category:       category,
+          consensus:      consensus_value,
+          submissionType: node.attr("submission-type") || "IETF",
+          iprExtract:     node.attr("ipr-extract"),
+          docName:        (node.attr("name") unless is_rfc),
+          number:         (node.attr("name") if is_rfc),
+          seriesNo:       node.attr("series-no"),
+          "xml:lang":     node.attr("xml-lang"),
+        }
+
+        rfc_open = noko { |xml| xml.rfc **attr_code(rfc_attributes) }.join.gsub(/\/>$/, ">")
+        result << rfc_open
+
+        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)
+        # Validate::validate(ret1)
+        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|
+          Nokogiri::XML::EntityDecl::new(entity[:entity], doc,
+                                         Nokogiri::XML::EntityDecl::EXTERNAL_GENERAL_PARSED,
+                                         nil, entity[:url], nil)
+          entity[:node].replace(Nokogiri::XML::EntityReference.new(doc, entity[:entity]))
+        end
+        doc
+      end
+
+      def inline_break(node)
+        noko do |xml|
+          xml << node.text
+          xml.vspace
+        end.join
+      end
+
+      def inline_quoted(node)
+        noko do |xml|
+          case node.type
+          when :emphasis
+            xml.spanx node.text, style: "emph"
+          when :strong
+            xml.spanx node.text, style: "strong"
+          when :monospaced
+            xml.spanx node.text, style: "verb"
+          when :double
+            xml << ($smart_quotes ? "“#{node.text}”" : "\"#{node.text}\"")
+          when :single
+            xml << ($smart_quotes ? "‘#{node.text}’" : "'#{node.text}'")
+          when :superscript
+            xml << "^#{node.text}^"
+          when :subscript
+            xml << "_#{node.text}_"
+          else
+            # [bcp14]#MUST NOT#
+            if node.role == "bcp14"
+              xml.spanx node.text.upcase, style: "strong"
+            elsif node.role == "comment"
+              xml.comment " " + node.text + " "
+            else
+              xml << node.text
+            end
+          end
+        end.join
+      end
+
+      # Syntax:
+      #   [[id]]
+      #   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,
+        }
+
+        noko do |xml|
+          xml.t **attr_code(t_attributes) do |xml_t|
+            xml_t << node.content
+          end
+        end.join("\n")
+      end
+
+      def verse(node)
+        result = []
+
+        t_attributes = {
+          anchor: node.id,
+        }
+
+        result << noko do |xml|
+          xml.t **attr_code(t_attributes) do |xml_t|
+            xml_t << node.content.gsub("\n\n", "<vspace blankLines=\"1\"/>").gsub("\n", "<vspace/>\n")
+          end
+        end
+
+        result
+      end
+
+      # Syntax:
+      #   [[id]]
+      #   == title
+      #   Content
+      #
+      #   [bibliography]
+      #   == References
+      #
+      #   [bibliography]
+      #   === Normative|Informative References
+      #   ++++
+      #   RFC XML references
+      #   ++++
+      def section(node)
+        result = []
+        if node.attr("style") == "bibliography" ||
+            node.parent.context == :section && node.parent.attr("style") == "bibliography"
+          $xreftext = {}
+          $processing_reflist = true
+
+          references_attributes = {
+            title: node.title,
+          }
+          if node.blocks.empty?
+            result << noko { |xml| xml.references **references_attributes }
+          end
+          node.blocks.each do |block|
+            if block.context == :section
+              result << node.content
+            elsif block.context == :pass
+              # NOTE: references are assumed to be found in a single passthrough
+              #   block containing <reference> tags.
+
+              result << noko do |xml|
+                xml.references **references_attributes do |xml_references|
+                  # 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
+            end
+          end
+
+          result = result.unshift("</middle><back>") unless $seen_back_matter
+          $processing_reflist = false
+          $seen_back_matter = true
+        else
+          if node.attr("style") == "appendix"
+            result << "</middle><back>" unless $seen_back_matter
+            $seen_back_matter = true
+          end
+
+          section_attributes = {
+            anchor: node.id,
+            title: node.title.gsub(/<[^>]+>/, ""),
+          }
+
+          result << noko do |xml|
+            xml.section **attr_code(section_attributes) do |xml_section|
+              xml_section << node.content
+            end
+          end
+        end
+
+        result
+      end
+
+      # Syntax:
+      #   [[id]]
+      #   .Name
+      #   [link=xxx,align=left|center|right,alt=alt_text,type]
+      #   image::filename[alt_text,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,
+          height: node.attr("height"),
+          name: node.title,
+          src: uri,
+          type: node.attr("type"),
+          width: node.attr("width"),
+        }
+
+        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 **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) do |config|
+          config.noent
+        end
+
+        # 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 = xmldoc.xpath("//cref")
+        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
+        # any instances of spanx must be stripped of any internal tags
+        spanxs = xmldoc.xpath("//spanx[descendant::*]")
+        while !spanxs.empty?
+          spanx = spanxs[0]
+          spanx_text = ""
+          spanx.traverse do |node|
+            spanx_text = spanx_text + node.text.gsub(/<[^>]+>/, "") if node.text?
+          end
+          spanx.children = spanx_text
+          spanxs = xmldoc.xpath("//spanx[descendant::*]")
+        end
+
+        xmldoc.root = merge_vspace(xmldoc.root)
+        xmldoc = smart_quote_cleanup(xmldoc) unless $smart_quotes
+        xmldoc.to_xml(encoding: "US-ASCII")
+      end
+
+      def merge_vspace(node)
+        nodes = []
+        newnodes = []
+        node.children.each do |element|
+          nodes << element
+        end
+
+        counter = 0
+        while counter < nodes.size
+          if nodes[counter].name == "vspace"
+            blankLines = 0
+            while counter < nodes.size && nodes[counter].name == "vspace"
+              blankLines += 1
+              if nodes[counter][:blankLines].nil?
+                blankLines += nodes[counter][:blankLines].to_i
+              end
+              if counter + 1 < nodes.size && nodes[counter + 1].text? && nodes[counter + 1].text =~ /\A[\n ]+\Z/m
+                counter += 1
+              end
+              counter += 1
+            end
+            counter -= 1 if counter == nodes.size
+            newnodes << noko do |xml|
+              xml.vspace **attr_code(blankLines: (blankLines - 1))
+            end.join
+          else
+            newnodes << merge_vspace(nodes[counter])
+            counter += 1
+          end
+        end
+        node.children.remove
+        newnodes.each do |item|
+          node.add_child(item)
+        end
+        node
+      end
+
+      # replace any <t>text</t> instances with <vspace blankLines="1"/>text
+      def para_to_vspace(doc)
+        xmldoc = Nokogiri::XML("<fragment>#{doc}</fragment>")
+        paras = xmldoc.xpath("/fragment/t")
+        paras.each do |para|
+          # we do not insert vspace if the para contains a list: space will go there anyway
+          unless para.element_children.size == 1 && para.element_children[0].name == "list"
+            vspace = Nokogiri::XML::Element.new("vspace", xmldoc.document)
+            vspace["blankLines"] = "1"
+            para.before(vspace)
+          end
+          para.replace(para.children)
+        end
+        xmldoc.root.children.to_xml(encoding: "US-ASCII")
+      end
+    end
+  end
+end