asciidoctor-rfc 0.1.0 → 0.2.0

data/Rakefile

@@ -3,4 +3,4 @@ require "rspec/core/rake_task"
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => :spec
+task default: :spec

data/asciidoctor-rfc.gemspec

@@ -1,14 +1,19 @@
 # coding: utf-8
+
 lib = File.expand_path("../lib", __FILE__)
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require "asciidoctor/rfc/version"
 
 Gem::Specification.new do |spec|
   spec.name          = "asciidoctor-rfc"
-  spec.version       = Asciidoctor::Rfc::VERSION
+  spec.version       = Asciidoctor::RFC::VERSION
   spec.authors       = ["Ribose Inc."]
   spec.email         = ["open.source@ribose.com"]
-  spec.summary       = %q{todo: AsciiDoctorRFC description.}
+
+  spec.summary       = "todo: AsciiDoctorRFC summary."
+  spec.description   = <<~DESCRIPTION
+  DESCRIPTION
+
   spec.homepage      = "https://github.com/riboseinc/asciidoctor-rfc"
   spec.license       = "MIT"
 
@@ -16,9 +21,21 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.files         = `git ls-files`.split("\n")
   spec.test_files    = `git ls-files -- {spec}/*`.split("\n")
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.1.9")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+
+  spec.add_dependency "asciidoctor", "~> 1.5.6"
+  spec.add_dependency "htmlentities", "~> 4.3.4"
+  spec.add_dependency "nokogiri", "~> 1.8.1"
+  spec.add_dependency "thread_safe"
 
   spec.add_development_dependency "bundler", "~> 1.15"
   spec.add_development_dependency "rake", "~> 12.0"
   spec.add_development_dependency "rspec", "~> 3.6"
+  spec.add_development_dependency "simplecov", "~> 0.15"
+  spec.add_development_dependency "byebug", "~> 9.1"
+  spec.add_development_dependency "guard", "~> 2.14"
+  spec.add_development_dependency "guard-rspec", "~> 4.7"
+  spec.add_development_dependency "timecop", "~> 0.9"
+  spec.add_development_dependency "equivalent-xml", "~> 0.6"
+  spec.add_development_dependency "rubocop", "~> 0.50"
 end

data/bin/asciidoctor-rfc2

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "asciidoctor/cli"
+require "asciidoctor/rfc/v2/converter"
+# require "asciidoctor-bibliography"
+
+options = Asciidoctor::Cli::Options.new backend: "rfc2", header_footer: true
+# FIXME This is a really bizarre API. Please make me simpler.
+
+exit 0 if options.parse!(ARGV) == 0
+
+invoker = Asciidoctor::Cli::Invoker.new options
+GC.start
+invoker.invoke!
+exit invoker.code

data/bin/asciidoctor-rfc3

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require "asciidoctor/cli"
+require "asciidoctor/rfc/v3/converter"
+# require "asciidoctor-bibliography"
+
+options = Asciidoctor::Cli::Options.new backend: "rfc3", header_footer: true
+# FIXME This is a really bizarre API. Please make me simpler.
+
+exit 0 if options.parse!(ARGV) == 0
+
+invoker = Asciidoctor::Cli::Invoker.new options
+GC.start
+invoker.invoke!
+exit invoker.code

data/bin/rspec

@@ -1,5 +1,4 @@
 #!/usr/bin/env ruby
-# frozen_string_literal: true
 
 # This file was generated by Bundler.
 #

data/lib/asciidoctor-rfc.rb

@@ -0,0 +1,4 @@
+require 'asciidoctor' unless defined? Asciidoctor::Converter
+require_relative 'asciidoctor/rfc/v2/converter'
+require_relative 'asciidoctor/rfc/v3/converter'
+require_relative 'asciidoctor/rfc/version'

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

@@ -0,0 +1,218 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+
+module Asciidoctor
+  module RFC::Common
+    module Base
+      def convert(node, transform = nil, opts = {})
+        transform ||= node.node_name
+        opts.empty? ? (send transform, node) : (send transform, node, opts)
+      end
+
+      def document_ns_attributes(_doc)
+        # ' xmlns="http://projectmallard.org/1.0/" xmlns:its="http://www.w3.org/2005/11/its"'
+        nil
+      end
+
+      def content(node)
+        node.content
+      end
+
+      def skip(node, name = nil)
+        warn %(asciidoctor: WARNING: converter missing for #{name || node.node_name} node in RFC backend)
+        nil
+      end
+
+      # Syntax:
+      #   = Title
+      #   Author
+      #   :HEADER
+      #
+      #   ABSTRACT
+      #
+      #   NOTE: note
+      #
+      # @note (boilerplate is ignored)
+      def preamble(node)
+        result = []
+        $seen_abstract = false
+        result << node.content
+        if $seen_abstract
+          result << "</abstract>"
+        end
+        result << "</front><middle>"
+        result
+      end
+
+      # TODO: dead code? remove.
+      # def authorname(node, suffix)
+      #   noko do |xml|
+      #     author_attributes = {
+      #       fullname: node.attr("author#{suffix}") || node.attr("fullname#{suffix}"),
+      #       surname: node.attr("lastname#{suffix}"),
+      #       initials: node.attr("forename_initials#{suffix}"),
+      #       role: node.attr("role#{suffix}"),
+      #     }.reject { |_, value| value.nil? }
+      #     xml.author **author_attributes
+      #   end
+      # end
+
+      # Syntax:
+      #   = Title
+      #   Author
+      #   :area x, y
+      def area(node, xml)
+        node.attr("area")&.split(/, ?/)&.each do |ar|
+          xml.area { |a| a << ar }
+        end
+      end
+
+      # Syntax:
+      #   = Title
+      #   Author
+      #   :workgroup x, y
+      def workgroup(node, xml)
+        node.attr("workgroup")&.split(/, ?/)&.each do |wg|
+          xml.workgroup { |w| w << wg }
+        end
+      end
+
+      # Syntax:
+      #   = Title
+      #   Author
+      #   :keyword x, y
+      def keyword(node, xml)
+        node.attr("keyword")&.split(/, ?/)&.each do |kw|
+          xml.keyword { |k| k << kw }
+        end
+      end
+
+      def paragraph1(node)
+        result = []
+        result1 = node.content
+        if result1 =~ /^(<t>|<dl>|<ol>|<ul>)/
+          result = result1
+        else
+          t_attributes = {
+            anchor: node.id,
+          }
+          result << noko { |xml| xml.t result1, **attr_code(t_attributes) }
+        end
+        result
+      end
+
+      def inline_indexterm(node)
+        # supports only primary and secondary terms
+        # primary attribute (highlighted major entry) not supported
+        if node.type == :visible
+          iref_attributes = {
+            item: node.text,
+          }
+          node.text + noko { |xml| xml.iref **attr_code(iref_attributes) }.join
+        else
+          terms = node.attr "terms"
+          warn %(asciidoctor: WARNING: only primary and secondary index terms supported: #{terms.join(': ')}) if terms.size > 2
+          iref_attributes = {
+            item: terms[0],
+            subitem: (terms.size > 1 ? terms[1] : nil),
+          }
+          noko { |xml| xml.iref **attr_code(iref_attributes) }.join
+        end
+      end
+
+      # ulist repurposed as reference list
+      def reflist(node)
+        # ++++
+        # <xml>
+        # ++++
+        result = []
+        if node.context == :pass
+          node.lines.each do |item|
+            # undo XML substitution
+            ref = item.gsub(/\&lt;/, "<").gsub(/\&gt;/, ">")
+            result << ref
+          end
+        else
+          warn %(asciidoctor: WARNING: references are not raw XML: #{node.context})
+        end
+        result
+      end
+
+      def open(node)
+        # open block is a container of multiple blocks, treated as a single block.
+        # We append each contained block to its parent
+        result = []
+        if node.blocks?
+          node.blocks.each do |b|
+            result << send(b.context, b)
+          end
+        else
+          result << paragraph(node)
+        end
+        result
+      end
+
+      def dash(camel_cased_word)
+        camel_cased_word.gsub(/([a-z])([A-Z])/, '\1-\2').downcase
+      end
+
+      # if node contains blocks, flatten them into a single line
+      def flatten(node)
+        result = []
+        result << node.text if node.respond_to?(:text)
+        if node.blocks?
+          node.blocks.each { |b| result << flatten(b) }
+        else
+          result << node.content
+        end
+        result.reject(&:empty?)
+      end
+
+      # if node contains blocks, flatten them into a single line; and extract only raw text
+      def flatten_rawtext(node)
+        result = []
+        if node.blocks?
+          node.blocks.each { |b| result << flatten_rawtext(b) }
+        elsif node.respond_to?(:lines)
+          node.lines.each do |x|
+            result << x.gsub(/</, "&lt;").gsub(/>/, "&gt;")
+          end
+        elsif node.respond_to?(:text)
+          result << node.text.gsub(/<[^>]*>/, "")
+        else
+          result << node.content.gsub(/<[^>]*>/, "")
+        end
+        result.reject(&:empty?)
+      end
+
+      def noko(&block)
+        # fragment = ::Nokogiri::XML::DocumentFragment.parse("")
+        # fragment.doc.create_internal_subset("xml", nil, "xhtml.dtd")
+        head = <<HERE
+        <!DOCTYPE html SYSTEM
+        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+        <html xmlns="http://www.w3.org/1999/xhtml">
+        <head>
+        <title></title>
+        <meta charset="UTF-8" />
+        </head>
+        <body>
+        </body>
+        </html>
+HERE
+        doc = ::Nokogiri::XML.parse(head)
+        fragment = doc.fragment("")
+        ::Nokogiri::XML::Builder.with fragment, &block
+        fragment.to_xml(encoding: "US-ASCII").lines.map { |l| l.gsub(/\s*\n/, "") }
+      end
+
+      def attr_code(attributes)
+        attributes = attributes.reject { |_, val| val.nil? }.map
+        attributes.map do |k, v|
+          [k, (v.is_a? String) ? HTMLEntities.new.decode(v) : v]
+        end.to_h
+      end
+    end
+  end
+end

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
+          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,
+            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: revdate attribute missing from header, provided current date)
+        end
+        unless revdate.nil?
+          begin
+            date1(revdate, xml)
+          rescue ArgumentError # invalid date
+            warn %(asciidoctor: WARNING: 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,341 @@
+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
+        $seen_abstract = false
+        $smart_quotes = (node.attr("smart-quotes") != "false")
+
+        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")
+
+        rfc_attributes = {
+          ipr:            node.attr("ipr"),
+          obsoletes:      node.attr("obsoletes"),
+          updates:        node.attr("updates"),
+          category:       node.attr("status"),
+          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 = set_pis(node, Nokogiri::XML(ret)).to_xml
+        ret = cleanup(ret)
+        Validate::validate(ret)
+        ret
+      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"
+            else
+              xml << node.text
+            end
+          end
+        end.join
+      end
+
+      # Syntax:
+      #   [[id]]
+      #   Text
+      def paragraph(node)
+        result = []
+
+        if (node.parent.context == :preamble) && !$seen_abstract
+          $seen_abstract = true
+          result << "<abstract>"
+        end
+
+        t_attributes = {
+          anchor: node.id,
+        }
+
+        result << noko do |xml|
+          xml.t **attr_code(t_attributes) do |xml_t|
+            xml_t << node.content
+          end
+        end
+        result
+      end
+
+      def verse(node)
+        result = []
+
+        if (node.parent.context == :preamble) && !$seen_abstract
+          $seen_abstract = true
+          result << "<abstract>"
+        end
+
+        t_attributes = {
+          anchor: node.id,
+        }
+
+        result << noko do |xml|
+          xml.t **attr_code(t_attributes) do |xml_t|
+            xml_t << node.content.gsub("\n", "<vspace/>\n")
+          end
+        end
+
+        result
+      end
+
+      # Syntax:
+      #   [[id]]
+      #   == title
+      #   Content
+      #
+      #   [bibliography]
+      #   == Normative|Informative References
+      #   * [[[ref1]]] Ref [must provide references as list]
+      #   * [[[ref2]]] Ref
+      def section(node)
+        result = []
+        if node.attr("style") == "bibliography"
+          $xreftext = {}
+          $processing_reflist = true
+
+          references_attributes = {
+            title: node.title,
+          }
+
+          result << noko do |xml|
+            xml.references **attr_code(references_attributes) do |xml_references|
+              node.blocks.each { |b| xml_references << reflist(b).join }
+            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,
+          }
+
+          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
+            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) do |config|
+          config.noent
+        end
+        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
+        unless $smart_quotes
+          xmldoc.traverse do |node|
+            if node.text?
+              node.content = node.content.tr("\u2019", "'")
+              node.content = node.content.gsub(/\&#8217;/, "'")
+              node.content = node.content.gsub(/\&#x2019;/, "'")
+            elsif node.element?
+              node.attributes.each do |k, v|
+                node.set_attribute(k, v.content.tr("\u2019", "'"))
+                node.set_attribute(k, v.content.gsub(/\&#8217;/, "'"))
+                node.set_attribute(k, v.content.gsub(/\&#x2019;/, "'"))
+              end
+            end
+          end
+        end
+        xmldoc.to_xml(encoding: "US-ASCII")
+      end
+
+      def set_pis(node, doc)
+        # Below are generally applicable Processing Instructions (PIs)
+        # that most I-Ds might want to use. (Here they are set differently than
+        # their defaults in xml2rfc v1.32)
+        rfc_pis = {
+          # give errors regarding ID-nits and DTD validation
+          strict: "yes",
+
+          # TOC control
+          # generate a ToC
+          toc: node.attr("toc-include") == "false" ? "no" : "yes",
+
+          # the number of levels of subsections in ToC. default: 3
+          tocdepth: node.attr("toc-depth") || "4",
+
+          # References control
+
+          # use symbolic references tags, i.e, [RFC2119] instead of [1]
+          symrefs: "yes",
+
+          # sort the reference entries alphabetically
+          sortrefs: "yes",
+
+          # Vertical whitespace control
+          # (using these PIs as follows is recommended by the RFC Editor)
+
+          # do not start each main section on a new page
+          compact: "yes",
+
+          # keep one blank line between list items
+          subcompact: "no",
+        }
+
+        doc.create_internal_subset("rfc", nil, "rfc2629.dtd")
+        rfc_pis.each_pair do |k, v|
+          pi = Nokogiri::XML::ProcessingInstruction.new(doc,
+                                                        "rfc",
+                                                        "#{k}=\"#{v}\"")
+          doc.root.add_previous_sibling(pi)
+        end
+
+        doc
+      end
+
+      # replace any <t>text</t> instances with <vspace/>text
+      def para_to_vspace(doc)
+        xmldoc = Nokogiri::XML("<fragment>#{doc}</fragment>")
+        paras = xmldoc.xpath("/fragment/t")
+        paras.each do |para|
+          vspace = Nokogiri::XML::Element.new("vspace", xmldoc.document)
+          para.before(vspace)
+          para.replace(para.children)
+        end
+        xmldoc.root.children.to_xml(encoding: "US-ASCII")
+      end
+    end
+  end
+end