metanorma-ietf 1.0.10 → 2.0.0

data/lib/isodoc/ietf/inline.rb

@@ -0,0 +1,136 @@
+require "mathml2asciimath"
+
+module IsoDoc::Ietf
+  class RfcConvert < ::IsoDoc::Convert
+    def em_parse(node, out)
+      out.em do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def sup_parse(node, out)
+      out.sup do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def sub_parse(node, out)
+      out.sub do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def tt_parse(node, out)
+      out.tt do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def strong_parse(node, out)
+      out.strong do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def bcp14_parse(node, out)
+      out.bcp14 do |e|
+        node.children.each { |n| parse(n, e) }
+      end
+    end
+
+    def strike_parse(node, out)
+      node.children.each { |n| parse(n, out) }
+    end
+
+    def smallcap_parse(node, out)
+      node.children.each { |n| parse(n, out) }
+    end
+
+    def keyword_parse(node, out)
+      node.children.each { |n| parse(n, out) }
+    end
+
+    def text_parse(node, out)
+      return if node.nil? || node.text.nil?
+      text = node.to_s
+      out << text
+    end
+
+    def stem_parse(node, out)
+      stem = case node["type"]
+             when "MathML" then MathML2AsciiMath.m2a(node.children.to_xml)
+             else
+               HTMLEntities.new.encode(node.text)
+             end
+      out << "#{@openmathdelim} #{stem} #{@closemathdelim}"
+    end
+
+    def page_break(_out)
+    end
+
+    def br_parse(node, out)
+      if @sourcecode
+        out.br
+      end
+    end
+
+    def hr_parse(node, out)
+    end
+
+    def link_parse(node, out)
+      out.eref **attr_code(target: node["target"]) do |l|
+        node.children.each { |n| parse(n, l) }
+      end
+    end
+
+    def image_parse(node, out, caption)
+      attrs = { src: node["src"], title: node["title"],
+                align: node["align"], name: node["filename"],
+                anchor: node["id"], type: "svg",
+                alt: node["alt"] }
+      out.artwork **attr_code(attrs)
+      image_title_parse(out, caption)
+    end
+
+    def image_title_parse(out, caption)
+      unless caption.nil?
+        out.t **{ align: "center", keepWithPrevious: "true" } do |p|
+          p << caption.to_s
+        end
+      end
+    end
+
+    def xref_parse(node, out)
+      out.xref **attr_code(target: node["target"], format: node["format"],
+                           relative: node["relative"]) do |l|
+                             l << get_linkend(node)
+                           end
+    end
+
+    def eref_parse(node, out)
+      linkend = node.children.select { |c| c.name != "locality" }
+      section = eref_clause(node.xpath(ns("./locality")), nil) || ""
+      out.relref **attr_code(target: node["bibitemid"], section: section,
+                             displayFormat: node["displayFormat"]) do |l|
+        linkend.each { |n| parse(n, l) }
+      end
+    end
+
+    def eref_clause(refs, target)
+      refs.each do |l|
+        next unless %w(clause section).include? l["type"]
+        return l&.at(ns("./referenceFrom"))&.text
+      end
+      return nil
+    end
+
+    def index_parse(node, out)
+      out.iref nil, **attr_code(item: node["primary"],
+                                subitem: node["secondary"])
+    end
+
+    def bookmark_parse(node, out)
+      out.bookmark nil, **attr_code(anchor: node["id"])
+    end
+  end
+end

data/lib/isodoc/ietf/metadata.rb

@@ -0,0 +1,62 @@
+require "isodoc"
+
+module IsoDoc
+  module Ietf
+    class  Metadata < IsoDoc::Metadata
+      TITLE_RFC = "//bibdata//title[@type='main' and @language='en']".freeze
+
+      def title(isoxml, _out)
+        t =  isoxml.at(ns(TITLE_RFC)) and
+          set(:doctitle, t.text)
+        t =  isoxml.at(ns(TITLE_RFC.sub(/main/, "abbrev"))) and
+          set(:docabbrev, t.text)
+        t =  isoxml.at(ns(TITLE_RFC.sub(/main/, "ascii"))) and
+          set(:docascii, t.text)
+      end
+
+      def relaton_relations
+        %w(included-in described-by derived-from equivalent)
+        # = item describedby convertedfrom alternate
+      end
+
+      def keywords(isoxml, _out)
+        ret = []
+        isoxml.xpath(ns("//bibdata/keyword")).each do |kw|
+          ret << kw.text
+        end
+        set(:keywords, ret)
+      end
+
+      def areas(isoxml, _out)
+        ret = []
+        isoxml.xpath(ns("//bibdata/ext/area")).each do |kw|
+          ret << kw.text
+        end
+        set(:areas, ret)
+      end
+
+      def docid(isoxml, _out)
+        dn = isoxml.at(ns("//bibdata/docnumber"))
+        set(:docnumber, dn&.text&.sub(/^rfc-/, "")&.sub(/\.[a-z0-9]+$/i, ""))
+      end
+
+      def author(xml, _out)
+        super
+        wg(xml)
+      end
+
+       def wg(xml)
+         workgroups = []
+         xml.xpath(ns("//bibdata/ext/editorialgroup/workgroup")).each do |wg|
+           workgroups << wg.text
+        end
+         set(:wg, workgroups)
+      end
+
+       def doctype(isoxml, _out)
+         super
+         set(:doctype, "Rfc") if get[:doctype].nil?
+       end
+    end
+  end
+end

data/lib/isodoc/ietf/references.rb

@@ -0,0 +1,129 @@
+module IsoDoc::Ietf
+  class RfcConvert < ::IsoDoc::Convert
+    # TODO displayreference will be implemented as combination of autofetch and user-provided citations
+
+    def bibliography(isoxml, out)
+      isoxml.xpath(ns("//references")).each do |f|
+        out.references **attr_code(anchor: f["id"]) do |div|
+          title = f.at(ns("./title")) and div.name do |name|
+            title.children.each { |n| parse(n, name) }
+          end
+          f.elements.reject do |e|
+            %w(reference title bibitem note).include? e.name
+          end.each { |e| parse(e, div) }
+          biblio_list(f, div, true)
+        end
+      end
+    end
+
+    def biblio_list(f, div, biblio)
+      i = 0
+      f.xpath(ns("./bibitem | ./note")).each do |b|
+        next if implicit_reference(b)
+        i += 1 if b.name == "bibitem"
+        if b.name == "note" then note_parse(b, div)
+        elsif(is_ietf(b)) then ietf_bibitem_entry(div, b, i)
+        else
+          nonstd_bibitem(div, b, i, biblio)
+        end
+      end
+    end
+
+    def nonstd_bibitem(list, b, ordinal, bibliography)
+      uris = b.xpath(ns("./uri"))
+      list.reference **attr_code(target: uris.empty? ? nil : uris[0]&.text,
+                                 anchor: b["id"]) do |r|
+        r.front do |f|
+          relaton_to_title(b, f)
+          relaton_to_author(b, f)
+          relaton_to_date(b, f)
+          relaton_to_keyword(b, f)
+          relaton_to_abstract(b, f)
+        end
+        uris[1..-1]&.each do |u|
+          r.format nil, **attr_code(target: u.text, type: u["type"])
+        end
+      end
+    end
+
+    def relaton_to_title(b, f)
+      id = bibitem_ref_code(b)
+      identifier = render_identifier(id)
+      title = b&.at(ns("./title")) || b&.at(ns("./formattedref")) or return
+      f.title do |t|
+        t << "#{identifier}, "
+        title.children.each { |n| parse(n, t) }
+      end
+    end
+
+    def relaton_to_author(b, f)
+      auths = b.xpath(ns("./contributor[xmlns:role/@type = 'author' or "\
+                 "xmlns:role/@type = 'editor']"))
+      auths.empty? and auths = b.xpath(ns("./contributor[xmlns:role/@type = "\
+                                          "'publisher']"))
+      auths.each do |a|
+        role = a.at(ns("./role[@type = 'editor']")) ? "editor" : nil
+        p = a&.at(ns("./person/name")) and 
+          relaton_person_to_author(p, role, f) or
+          relaton_org_to_author(a&.at(ns("./organization")), role, f)
+      end
+    end
+
+    def relaton_person_to_author(p, role, f)
+      fullname = p&.at(ns("./completename"))&.text
+      surname = p&.at(ns("./surname"))&.text
+      initials = p&.xpath(ns("./initial"))&.map { |i| i.text }&.join(" ") ||
+        p&.xpath(ns("./forename"))&.map { |i| i.text[0] }&.join(" ")
+      initials = nil if initials.empty?
+      f.author nil,
+        **attr_code(fullname: fullname, asciiFullname: fullname&.transliterate,
+                    role: role, surname: surname, initials: initials,
+                    asciiSurname: fullname ? surname&.transliterate : nil,
+                    asciiInitials: fullname ? initials&.transliterate : nil)
+    end
+
+    def relaton_org_to_author(o, role, f)
+      name = o&.at(ns("./name"))&.text
+      abbrev = o&.at(ns("./abbreviation"))&.text
+      f.author do |a|
+        f.organization name, **attr_code(ascii: name&.transliterate, 
+                                         abbrev: abbrev)
+      end
+    end
+
+    def relaton_to_date(b, f)
+      date = b.at(ns("./date[@type = 'published']")) ||
+        b.at(ns("./date[@type = 'issued']")) ||
+        b.at(ns("./date[@type = 'circulated']"))
+      return unless date
+      attr = date_attr(date&.at(ns("./on | ./from"))&.text) || return
+      f.date **attr_code(attr)
+    end
+
+    def relaton_to_keyword(b, f)
+      b.xpath(ns("./keyword")).each do |k|
+        f.keyword do |keyword|
+          k.children.each { |n| parse(n, keyword) }
+        end
+      end
+    end
+
+    def relaton_to_abstract(b, f)
+      b.xpath(ns("./abstract")).each do |k|
+        f.abstract do |abstract|
+          k.children.each { |n| parse(n, abstract) }
+        end
+      end
+    end
+
+    def ietf_bibitem_entry(div, b, i)
+      url = b&.at(ns("./uri[@type = 'xml']"))&.text
+      div << "<xi:include href='#{url}'/>"
+    end
+
+    def is_ietf(b)
+      url = b.at(ns("./uri[@type = 'xml']")) or return false
+      /xml2rfc\.tools\.ietf\.org/.match(url)
+    end
+  end
+end

data/lib/isodoc/ietf/reqt.rb

@@ -0,0 +1,74 @@
+module IsoDoc::Ietf
+  class RfcConvert < ::IsoDoc::Convert
+    def recommendation_name(node, out, type)
+      label, title, lbl = recommendation_labels(node)
+      out.t **{ keepWithNext: "true" }  do |b|
+        b << (lbl.nil? ? l10n("#{type}:") : l10n("#{type} #{lbl}:"))
+      end
+      if label || title
+        out.t **{ keepWithNext: "true" }  do |b|
+          label and label.children.each { |n| parse(n,b) }
+          b << "#{clausedelim} " if label && title
+          title and title.children.each { |n| parse(n,b) }
+        end
+      end
+    end
+
+    def recommendation_attributes(node, out)
+      ret = recommendation_attributes1(node)
+      return if ret.empty?
+      out.ul do |p|
+        ret.each do |l|
+          p.li do |i|
+            i.em { |e| i << l }
+          end
+        end
+      end
+    end
+
+    def recommendation_parse(node, out)
+      recommendation_name(node, out, @recommendation_lbl)
+      recommendation_attributes(node, out)
+      node.children.each do |n|
+        parse(n, out) unless %w(label title).include? n.name
+      end
+    end
+
+    def requirement_parse(node, out)
+      recommendation_name(node, out, @requirement_lbl)
+      recommendation_attributes(node, out)
+      node.children.each do |n|
+        parse(n, out) unless %w(label title).include? n.name
+      end
+    end
+
+    def permission_parse(node, out)
+      recommendation_name(node, out, @permission_lbl)
+      recommendation_attributes(node, out)
+      node.children.each do |n|
+        parse(n, out) unless %w(label title).include? n.name
+      end
+    end
+
+    def inline?(node)
+      return true if node.first_element_child.nil?
+      %w(em link eref xref strong tt sup sub strike keyword smallcap
+         br hr bookmark pagebreak stem origin term preferred admitted
+         deprecates domain termsource modification).include? node.first_element_child.name
+    end
+
+    def requirement_component_parse(node, out)
+      return if node["exclude"] == "true"
+      out1 = out
+      if inline?(node)
+        out.t do |p|
+          p << "INHERIT: " if node.name == "inherit"
+          node.children.each { |n| parse(n, p) }
+        end
+      else
+        node.children.each { |n| parse(n, out) }
+      end
+    end
+  end
+end
+

data/lib/isodoc/ietf/rfc_convert.rb

@@ -0,0 +1,60 @@
+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"
+
+module IsoDoc::Ietf
+  class RfcConvert < ::IsoDoc::Convert
+    def convert1(docxml, filename, dir)
+      anchor_names 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, labels)
+      @meta = Metadata.new(lang, script, labels)
+    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 postprocess(result, filename, dir)
+      result = from_xhtml(cleanup(to_xhtml(result))).sub(/<!DOCTYPE[^>]+>\n/, "").
+        sub(/(<rfc[^<]+? )lang="[^"]+"/, "\\1")
+      File.open("#{filename}.rfc.xml", "w:UTF-8") { |f| f.write(result) }
+      @files_to_delete.each { |f| FileUtils.rm_rf f }
+    end
+  end
+end