metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/metanorma-ietf-2.2.0/lib/isodoc/ietf/rfc_convert.rb

@@ -0,0 +1,82 @@
+require_relative "./terms"
+require_relative "./blocks"
+require_relative "./metadata"
+require_relative "./front"
+require_relative "./table"
+require_relative "./inline"
+require_relative "./reqt"
+require_relative "./cleanup"
+require_relative "./footnotes"
+require_relative "./references"
+require_relative "./section"
+require_relative "./xref"
+
+module IsoDoc::Ietf
+  class RfcConvert < ::IsoDoc::Convert
+    def convert1(docxml, filename, dir)
+      @xrefs.parse docxml
+      info docxml, nil
+      xml = noko do |xml|
+        xml.rfc **attr_code(rfc_attributes(docxml)) do |html|
+          make_link(html, docxml)
+          make_front(html, docxml)
+          make_middle(html, docxml)
+          make_back(html, docxml)
+        end
+      end.join("\n").sub(/<!DOCTYPE[^>]+>\n/, "")
+          set_pis(docxml, Nokogiri::XML(xml))
+    end
+
+    def metadata_init(lang, script, i18n)
+      @meta = Metadata.new(lang, script, i18n)
+    end
+
+    def xref_init(lang, script, klass, i18n, options)
+        @xrefs = Xref.new(lang, script, klass, i18n, options)
+      end
+
+    def extract_delims(text)
+      @openmathdelim = "$$"
+      @closemathdelim = "$$"
+      while %r{#{Regexp.escape(@openmathdelim)}}m.match(text) ||
+          %r{#{Regexp.escape(@closemathdelim)}}m.match(text)
+        @openmathdelim += "$"
+        @closemathdelim += "$"
+      end
+      [@openmathdelim, @closemathdelim]
+    end
+
+    def error_parse(node, out)
+      case node.name
+      when "bcp14" then bcp14_parse(node, out)
+      else
+        text = node.to_xml.gsub(/</, "&lt;").gsub(/>/, "&gt;")
+        out.t { |p| p << text }
+      end
+    end
+
+     def textcleanup(docxml)
+      passthrough_cleanup(docxml)
+     end
+
+    def postprocess(result, filename, dir)
+      result = from_xhtml(cleanup(to_xhtml(textcleanup(result)))).
+        sub(/<!DOCTYPE[^>]+>\n/, "").
+        sub(/(<rfc[^<]+? )lang="[^"]+"/, "\\1")
+      File.open(filename, "w:UTF-8") { |f| f.write(result) }
+      @files_to_delete.each { |f| FileUtils.rm_rf f }
+    end
+
+    def init_file(filename, debug)
+      filename = filename.sub(/\.rfc\.xml$/, ".rfc")
+      super
+    end
+
+    def initialize(options)
+      super
+      @xinclude = options[:use_xinclude] == "true"
+      @format = :rfc
+      @suffix = "rfc.xml"
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-ietf-2.2.0/lib/isodoc/ietf/section.rb

@@ -0,0 +1,175 @@
+module IsoDoc::Ietf
+  class RfcConvert < ::IsoDoc::Convert
+    def common_rfc_pis(node)
+      rfc_pis = {
+         artworkdelimiter: node&.at(ns("//pi/artworkdelimiter"))&.text,
+        artworklines: node&.at(ns("//pi/artworklines"))&.text,
+        authorship: node&.at(ns("//pi/authorship"))&.text,
+        autobreaks: node&.at(ns("//pi/autobreaks"))&.text,
+        background: node&.at(ns("//pi/background"))&.text,
+        colonspace: node&.at(ns("//pi/colonspace"))&.text,
+        comments: node&.at(ns("//pi/comments"))&.text,
+        docmapping: node&.at(ns("//pi/docmapping"))&.text,
+        editing: node&.at(ns("//pi/editing"))&.text,
+        emoticonic: node&.at(ns("//pi/emoticonic"))&.text,
+        footer: node&.at(ns("//pi/footer"))&.text,
+        header: node&.at(ns("//pi/header"))&.text,
+        inline: node&.at(ns("//pi/inline"))&.text,
+        iprnotified: node&.at(ns("//pi/iprnotified"))&.text,
+        linkmailto: node&.at(ns("//pi/linkmailto"))&.text,
+        linefile: node&.at(ns("//pi/linefile"))&.text,
+        notedraftinprogress: node&.at(ns("//pi/notedraftinprogress"))&.text,
+        private: node&.at(ns("//pi/private"))&.text,
+        refparent: node&.at(ns("//pi/refparent"))&.text,
+        rfcedstyle: node&.at(ns("//pi/rfcedstyle"))&.text,
+        slides: node&.at(ns("//pi/slides"))&.text,
+        "text-list-symbols": node&.at(ns("//pi/text-list-symbols"))&.text,
+        tocappendix: node&.at(ns("//pi/tocappendix"))&.text,
+        tocindent: node&.at(ns("//pi/tocindent"))&.text,
+        tocnarrow: node&.at(ns("//pi/tocnarrow"))&.text,
+        tocompact: node&.at(ns("//pi/tocompact"))&.text,
+        topblock: node&.at(ns("//pi/topblock"))&.text,
+        useobject: node&.at(ns("//pi/useobject"))&.text,
+        strict: node&.at(ns("//pi/strict"))&.text || "yes",
+        compact: node&.at(ns("//pi/compact"))&.text || "yes",
+        subcompact: node&.at(ns("//pi/subcompact"))&.text || "no",
+        toc: node&.at(ns("//pi/toc-include"))&.text,
+        tocdepth: node&.at(ns("//pi/toc-depth"))&.text || "4",
+        symrefs: node&.at(ns("//pi/sym-refs"))&.text || "yes",
+        sortrefs: node&.at(ns("//pi/sort-refs"))&.text || "yes",
+      }
+      attr_code(rfc_pis)
+    end
+
+    def set_pis(node, doc)
+      rfc_pis = common_rfc_pis(node)
+      rfc_pis.each_pair do |k, v|
+        pi = Nokogiri::XML::ProcessingInstruction.new(doc, "rfc",
+                                                      "#{k}=\"#{v}\"")
+        doc.root.add_previous_sibling(pi)
+      end
+      doc.to_xml
+    end
+
+    def rfc_attributes(docxml)
+      t = Time.now.getutc
+      obs = xpath_comma(docxml.xpath(ns(
+        "//bibdata/relation[@type = 'obsoletes']/bibitem/docidentifier")))
+      upd = xpath_comma(docxml.xpath(ns(
+        "//bibdata/relation[@type = 'updates']/bibitem/docidentifier")))
+      {
+        docName:        @meta.get[:doctype] == "Internet Draft" ? @meta.get[:docnumber] : nil,
+        number:         @meta.get[:doctype].casecmp?("rfc") ? @meta.get[:docnumber] : nil,
+        category:       series2category(
+          docxml&.at(ns("//bibdata/series[@type = 'intended']/title"))&.text),
+        ipr:            docxml&.at(ns("//bibdata/ext/ipr"))&.text,
+        obsoletes:      obs,
+        updates:        upd,
+        indexInclude:   docxml&.at(ns("//bibdata/ext/indexInclude"))&.text,
+        iprExtract:     docxml&.at(ns("//bibdata/ext/iprExtract"))&.text,
+        sortRefs:       docxml&.at(ns("//bibdata/ext/sortRefs"))&.text,
+        symRefs:        docxml&.at(ns("//bibdata/ext/symRefs"))&.text,
+        tocInclude:     docxml&.at(ns("//bibdata/ext/tocInclude"))&.text,
+        tocDepth:       docxml&.at(ns("//bibdata/ext/tocDepth"))&.text,
+        submissionType: docxml&.at(ns(
+          "//bibdata/series[@type = 'stream']/title"))&.text || "IETF",
+        'xml:lang':     docxml&.at(ns("//bibdata/language"))&.text,
+        version:        "3",
+        'xmlns:xi':        "http://www.w3.org/2001/XInclude",
+      }
+    end
+
+    def series2category(series)
+      case series&.downcase
+      when "standard", "std" then "std"
+      when "informational", "info" then "info"
+      when "experimental", "exp" then "exp"
+      when "bcp" then "bcp"
+      when "fyi", "info" then "info"
+      when "full-standard" then "std"
+      when "historic" then "historic"
+      else
+        "std"
+      end
+    end
+
+    def xpath_comma(xpath)
+      return nil if xpath.empty?
+      xpath.map { |x| x.text }.join(", ")
+    end
+
+    def make_link(out, isoxml)
+      links = isoxml.xpath(ns(
+        "//bibdata/relation[@type = 'includedIn' or @type = 'describedBy' or "\
+        "@type = 'derivedFrom' or @type = 'instance']")) || return
+        links.each do |l|
+          out.link **{ href: l&.at(ns("./bibitem/docidentifier"))&.text,
+                       rel: rel2iana(l["type"]) }
+        end
+    end
+
+    def rel2iana(type)
+      case type
+      when "includedIn" then "item"
+      when "describedBy" then "describedby"
+      when "derivedFrom" then "convertedfrom"
+      when "instance" then "alternate"
+      else 
+        "alternate"
+      end
+    end
+
+    def make_middle(out, isoxml)
+      out.middle do |middle|
+        clause isoxml, middle
+      end
+    end
+
+    def make_back(out, isoxml)
+      out.back do |back|
+        bibliography isoxml, back
+        annex isoxml, back
+      end
+    end
+
+    def clause_parse_title(node, div, c1, out, _heading_attrs = {})
+      return unless c1
+      div.name do |n|
+        c1&.children&.each { |c2| parse(c2, n) }
+      end
+    end
+
+    def clause_parse(node, out)
+      out.section **attr_code( anchor: node["id"], numbered: node["numbered"],
+                              removeInRFC: node["removeInRFC"], toc: node["toc"]) do |div|
+        clause_parse_title(node, div, node.at(ns("./title")), out)
+        node.children.reject { |c1| c1.name == "title" }.each do |c1|
+          parse(c1, div)
+        end
+      end
+    end
+
+    def clause(isoxml, out)
+      isoxml.xpath("//xmlns:preface/child::*[not(name() = 'abstract' or name() = 'foreword')] "\
+                   "| //xmlns:sections/child::*").each do |c|
+        clause1(c, out)
+      end
+    end
+
+    def clause1(c, out)
+      out.section **attr_code( anchor: c["id"], numbered: c["numbered"],
+                              removeInRFC: c["removeInRFC"], toc: c["toc"]) do |div|
+        clause_parse_title(c, div, c.at(ns("./title")), out)
+        c.elements.reject { |c1| c1.name == "title" }.each do |c1|
+          parse(c1, div)
+        end
+      end
+    end
+
+    def annex(isoxml, out)
+      isoxml.xpath(ns("//annex")).each do |c|
+        clause1(c, out)
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-ietf-2.2.0/lib/isodoc/ietf/table.rb

@@ -0,0 +1,43 @@
+module IsoDoc::Ietf
+  class RfcConvert < ::IsoDoc::Convert
+    def table_attrs(node)
+      attr_code(anchor: node["id"], align: node["align"])
+    end
+
+    def table_parse(node, out)
+      @in_table = true
+      out.table **table_attrs(node) do |t|
+        table_title_parse(node, out)
+        thead_parse(node, t)
+        tbody_parse(node, t)
+        tfoot_parse(node, t)
+      end
+      (dl = node.at(ns("./dl"))) && parse(dl, out)
+      node.xpath(ns("./note")).each { |n| parse(n, out) }
+      @in_table = false
+    end
+
+    def table_title_parse(node, out)
+      name = node.at(ns("./name")) || return
+      out.name do |p|
+        name.children.each { |n| parse(n, p) }
+      end
+    end
+
+    def tr_parse(node, out, ord, totalrows, header)
+      out.tr do |r|
+        node.elements.each do |td|
+          attrs = make_tr_attr(td, ord, totalrows - 1, header)
+          r.send td.name, **attrs do |entry|
+            td.children.each { |n| parse(n, entry) }
+          end
+        end
+      end
+    end
+
+    def make_tr_attr(td, row, totalrows, header)
+      attr_code(rowspan: td["rowspan"], colspan: td["colspan"],
+                align: td["align"] )
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-ietf-2.2.0/lib/isodoc/ietf/terms.rb

@@ -0,0 +1,52 @@
+module IsoDoc::Ietf
+  class RfcConvert < ::IsoDoc::Convert
+
+    def definition_parse(node, out)
+      node.children.each { |n| parse(n, out) }
+    end
+
+    def modification_parse(node, out)
+      para = node.at(ns("./p"))
+      out << " -- "
+      para.children.each { |n| parse(n, out) }
+    end
+
+    def deprecated_term_parse(node, out)
+      out.t do |p|
+        p << l10n("#{@i18n.deprecated}: ")
+        node.children.each { |c| parse(c, p) }
+      end
+    end
+
+    def admitted_term_parse(node, out)
+      out.t do |p|
+        node.children.each { |c| parse(c, p) }
+      end
+    end
+
+    def term_parse(node, out)
+      out.name do |p|
+        node.children.each { |n| parse(n, p) }
+      end
+    end
+
+    def termnote_parse(node, out)
+      note_parse(node, out)
+    end
+
+    def termref_parse(node, out)
+      out.t do |p|
+        p << "SOURCE: "
+        node.children.each { |n| parse(n, p) }
+      end
+    end
+
+    def termdef_parse(node, out)
+      set_termdomain("")
+      clause_parse(node, out)
+    end
+
+    def termdocsource_parse(_node, _out)
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-ietf-2.2.0/lib/isodoc/ietf/xref.rb

@@ -0,0 +1,20 @@
+require "isodoc"
+
+module IsoDoc
+  module Ietf
+    class Xref < IsoDoc::Xref
+      def termnote_anchor_names(docxml)
+        docxml.xpath(ns("//term[descendant::termnote]")).each do |t|
+          c = IsoDoc::XrefGen::Counter.new
+          notes = t.xpath(ns(".//termnote"))
+          notes.each do |n|
+            next if n["id"].nil? || n["id"].empty?
+            idx = notes.size == 1 ? "" : " #{c.increment(n).print}"
+            @anchors[n["id"]] =
+              anchor_struct(idx, n, @labels["note_xref"], "note", false)
+          end
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-ietf-2.2.0/lib/metanorma-ietf.rb

@@ -0,0 +1,8 @@
+require "asciidoctor" unless defined? Asciidoctor::Converter
+require "metanorma"
+
+require_relative "metanorma/ietf"
+require_relative "asciidoctor/ietf/converter"
+require_relative "isodoc/ietf/rfc_convert"
+
+Metanorma::Registry.instance.register(Metanorma::Ietf::Processor)

data/gems/ruby/2.6.0/gems/metanorma-ietf-2.2.0/lib/metanorma/ietf.rb

@@ -0,0 +1,8 @@
+require_relative "ietf/processor"
+require_relative "ietf/version"
+
+module Metanorma
+  module Ietf
+  	RFC2629DTD_URL = "https://raw.githubusercontent.com/metanorma/metanorma-ietf/master/rfc2629.dtd"
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-ietf-2.2.0/lib/metanorma/ietf/processor.rb

@@ -0,0 +1,103 @@
+require "metanorma/processor"
+require "tempfile"
+
+module Metanorma
+  module Ietf
+    class Processor < Metanorma::Processor
+
+      def initialize
+        @short = :ietf
+        @input_format = :asciidoc
+        @asciidoctor_backend = :ietf
+      end
+
+      def output_formats
+        {
+          rxl: "rxl",
+          xml: "xml",
+          rfc: "rfc.xml",
+          html: "html",
+          txt: "txt",
+          pdf: "pdf"
+        }
+      end
+
+      def version
+        "Metanorma::Ietf #{::Metanorma::Ietf::VERSION}"
+      end
+
+      def extract_options(isodocxml)
+        {}
+      end
+
+      # From mislav: https://stackoverflow.com/questions/2108727
+      #        /which-in-ruby-checking-if-program-exists-in-path-from-ruby
+      def which(cmd)
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each do |ext|
+            exe = File.join(path, "#{cmd}#{ext}")
+            return exe if File.executable?(exe) && !File.directory?(exe)
+          end
+        end
+        nil
+      end
+
+      def use_presentation_xml(ext)
+        false
+      end
+
+      def xml2rfc_present?
+        !which("xml2rfc").nil?
+      end
+
+      def output(isodoc_node, inname, outname, format, options={})
+        case format
+        when :rfc
+          outname ||= inname.sub(/\.xml$/, ".rfc.xml")
+          IsoDoc::Ietf::RfcConvert.new(options).convert(inname, isodoc_node, nil, outname)
+          @done_rfc = true
+
+        when :txt
+          unless xml2rfc_present?
+            warn "[metanorma-ietf] Error: unable to generate #{format}, the command `xml2rfc` is not found in path."
+            return
+          end
+
+          rfcname = inname.sub(/\.xml$/, ".rfc.xml")
+          output(isodoc_node, inname, rfcname, :rfc, options) unless @done_rfc
+
+          outname ||= inname.sub(/\.xml$/, ".txt")
+          system("xml2rfc --text #{rfcname} -o #{outname}")
+
+        when :pdf
+          unless xml2rfc_present?
+            warn "[metanorma-ietf] Error: unable to generate #{format}, the command `xml2rfc` is not found in path."
+            return
+          end
+
+          rfcname = inname.sub(/\.xml$/, ".rfc.xml")
+          output(isodoc_node, inname, rfcname, :rfc, options) unless @done_rfc
+
+          outname ||= inname.sub(/\.xml$/, ".pdf")
+          system("xml2rfc --pdf #{rfcname} -o #{outname}")
+
+        when :html
+          unless xml2rfc_present?
+            warn "[metanorma-ietf] Error: unable to generate #{format}, the command `xml2rfc` is not found in path."
+            return
+          end
+
+          rfcname = inname.sub(/\.xml$/, ".rfc.xml")
+          output(isodoc_node, inname, rfcname, :rfc, options) unless @done_rfc
+
+          outname ||= inname.sub(/\.xml$/, ".html")
+          system("xml2rfc --html #{rfcname} -o #{outname}")
+
+        else
+          super
+        end
+      end
+    end
+  end
+end