metanorma-ietf 1.0.10 → 2.0.0

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

@@ -1,330 +0,0 @@
-# coding: utf-8
-
-require_relative "../common/validate"
-
-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?
-        Asciidoctor::Rfc::Common::Validate::validate(ret1, File.join(File.dirname(__FILE__), "validate.rng"))
-        ret1 = resolve_references(node, 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 == :table_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.numbered
-          }
-
-          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

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