metanorma-cli 1.3.3.1 → 1.3.4

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

@@ -0,0 +1,230 @@
+module IsoDoc::Ietf
+  class RfcConvert < ::IsoDoc::Convert
+    def cleanup(docxml)
+      image_cleanup(docxml)
+      figure_cleanup(docxml)
+      table_cleanup(docxml)
+      footnote_cleanup(docxml)
+      sourcecode_cleanup(docxml)
+      annotation_cleanup(docxml)
+      deflist_cleanup(docxml)
+      bookmark_cleanup(docxml)
+      aside_cleanup(docxml)
+      front_cleanup(docxml)
+      docxml
+    end
+
+    # TODO: insert <u>
+    
+    def front_cleanup(xmldoc)
+        xmldoc.xpath("//title").each { |s| s.children = s.text }
+        xmldoc.xpath("//reference/front[not(author)]").each do |f|
+          insert = f.at("./seriesInfo[last()]") || f.at("./title")
+          insert.next = "<author surname='Unknown'/>"
+        end
+      end
+
+    def table_footnote_cleanup(docxml)
+      docxml.xpath("//table[descendant::fn]").each do |t|
+        t.xpath(".//fn").each do |a|
+          t << "<aside>#{a.remove.children}</aside>"
+        end
+      end
+    end
+
+    def figure_footnote_cleanup(docxml)
+      docxml.xpath("//figure[descendant::fn]").each do |t|
+        t.xpath(".//fn").each do |a|
+          t << "<aside>#{a.remove.children}</aside>"
+        end
+      end
+    end
+
+    def table_cleanup(docxml)
+      table_footnote_cleanup(docxml)
+    end
+
+    def figure_cleanup(docxml)
+      figure_postamble(docxml)
+      figure_wrap_artwork(docxml)
+      figure_unnest(docxml)
+      figure_footnote_cleanup(docxml)
+    end
+
+    def figure_wrap_artwork(docxml)
+      docxml.xpath("//artwork[not(parent::figure)] | "\
+                   "//sourcecode[not(parent::figure)]").each do |a|
+        a.wrap("<figure></figure>")
+      end
+    end
+
+    def figure_unnest(docxml)
+      docxml.xpath("//figure[descendant::figure]").each do |f|
+        insert = f
+        f.xpath(".//figure").each do |a|
+          insert.next = a.remove
+          insert = insert.next_element
+        end
+      end
+    end
+
+    def figure_postamble(docxml)
+      make_postamble(docxml)
+      move_postamble(docxml)
+      move_preamble(docxml)
+    end
+
+    def make_postamble(docxml)
+      docxml.xpath("//figure").each do |f|
+        a = f&.at("./artwork | ./sourcecode") || next
+        name = f&.at("./name")&.remove
+        b = a&.xpath("./preceding-sibling::*")&.remove
+        c = a&.xpath("./following-sibling::*")&.remove
+        a = a.remove
+        name and f << name
+        b.empty? or f << "<preamble>#{b.to_xml}</preamble>"
+        a and f << a
+        c.empty? or f << "<postamble>#{c.to_xml}</postamble>"
+      end
+    end
+
+    def move_postamble(docxml)
+      docxml.xpath("//postamble").each do |p|
+        insert = p.parent
+        p.remove.elements.each do |e|
+          insert.next = e
+          insert = insert.next_element
+        end
+      end
+    end
+
+    def move_preamble(docxml)
+      docxml.xpath("//preamble").each do |p|
+        insert = p.parent
+        p.remove.elements.each do |e|
+          insert.previous = e
+        end
+      end
+    end
+
+    def footnote_cleanup(docxml)
+      fn = footnote_refs_cleanup(docxml)
+      endnotes = make_endnotes(docxml)
+      docxml.xpath("//section[descendant::fn] | "\
+                   "//abstract[descendant::fn]").each do |s|
+        s.xpath(".//fn").each do |f|
+          ref = f.at(".//ref") and ref.replace("[#{fn[ref.text]}] ")
+          endnotes << f.remove.children
+        end
+      end
+    end
+
+    def footnote_refs_cleanup(docxml)
+      i = 0
+      fn = {}
+      docxml.xpath("//fnref").each do |f|
+        unless fn[f.text]
+          i = i + 1
+          fn[f.text] = i.to_s
+        end
+        f.replace(" [#{fn[f.text]}]")
+      end
+      fn
+    end
+
+    def make_endnotes(docxml)
+      return unless docxml.at("//fn")
+      endnotes = docxml.at("//back") or
+      docxml << "<back/>" and endnotes = docxml.at("//back")
+      endnotes << "<section><name>Endnotes</name></section>"
+      endnotes = docxml.at("//back/section[last()]")
+    end
+
+    def image_cleanup(docxml)
+      docxml.xpath("//t[descendant::artwork]").each do |t|
+        insert = t
+        t.xpath(".//artwork").each_with_index do |a, i|
+          insert.next = a.dup
+          insert = insert.next
+          a.replace("[IMAGE #{i+1}]")
+        end
+      end
+    end
+
+    # for markup in pseudocode
+    def sourcecode_cleanup(docxml)
+      docxml.xpath("//sourcecode").each do |s|
+        s.children = s.children.to_xml.gsub(%r{<br/>\n}, "\n").
+          gsub(%r{\s+(<t[ >])}, "\\1").gsub(%r{</t>\s+}, "</t>")
+        sourcecode_remove_markup(s)
+        text = HTMLEntities.new.decode(s.children.to_xml.sub(/\A\n+/, ""))
+        s.children = "<![CDATA[#{text}]]>"
+      end
+    end
+
+    def sourcecode_remove_markup(s)
+      s.traverse do |n|
+        next if n.text?
+        next if %w(name callout annotation note sourcecode).include? n.name
+        if n.name == "br" then n.replace("\n")
+        elsif n.name == "t" then n.replace("\n\n#{n.children}")
+        else
+          n.replace(n.children)
+        end
+      end
+    end
+
+    def annotation_cleanup(docxml)
+      docxml.xpath("//reference").each do |r|
+        next unless r&.next_element&.name == "aside"
+        aside = r.next_element
+        aside.name = "annotation"
+        aside.traverse do |n|
+          n.name == "t" and n.replace(n.children)
+        end
+        r << aside
+      end
+      docxml.xpath("//references/aside").each { |r| r.remove }
+    end
+
+    def deflist_cleanup(docxml)
+      dt_cleanup(docxml)
+      dd_cleanup(docxml)
+    end
+
+    def dt_cleanup(docxml)
+      docxml.xpath("//dt").each do |d|
+        d&.first_element_child&.name == "bookmark" and
+          d["anchor"] ||= d.first_element_child["anchor"]
+        d.xpath(".//t").each do |t|
+          d["anchor"] ||= t["anchor"]
+          t.replace(t.children)
+        end
+      end
+    end
+
+    def dd_cleanup(docxml)
+      docxml.xpath("//dd").each do |d|
+        d&.first_element_child&.name == "bookmark" and
+          d["anchor"] ||= d.first_element_child["anchor"]
+      end
+    end
+
+    def bookmark_cleanup(docxml)
+      docxml.xpath("//bookmark").each do |b|
+        b.remove
+      end
+    end
+
+    def aside_cleanup(docxml)
+      docxml.xpath("//t[descendant::aside] | //table[descendant::aside] | "\
+                   "//figure[descendant::aside]").each do |p|
+        insert = p
+        p.xpath(".//aside").each do |a|
+          insert.next = a.remove
+          insert = insert.next_element
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+module IsoDoc::Ietf
+  class RfcConvert < ::IsoDoc::Convert
+    def footnote_parse(node, out)
+      return table_footnote_parse(node, out) if @in_table || @in_figure
+      fn = node["reference"]
+      out.fnref fn
+      make_local_footnote(node, fn, out)
+    end
+
+    def make_local_footnote(node, fn, out)
+      return if @seen_footnote.include?(fn)
+      @in_footnote = true
+      out << make_generic_footnote_text(node, fn)
+      @in_footnote = false
+      @seen_footnote << fn
+    end
+
+    def make_generic_footnote_text(node, fnref)
+      first = node.first_element_child
+      noko do |xml|
+        xml.fn do |div|
+          xml.t **attr_code(anchor: first ? first["id"] : nil) do |div|
+            div.ref fnref
+            first.name == "p" and first.children.each { |n| parse(n, div) }
+          end
+          first.name == "p" and
+            node.elements.drop(1).each { |n| parse(n, xml) } or
+            node.children.each { |n| parse(n, xml) }
+        end
+      end.join
+    end
+
+    def table_footnote_parse(node, out)
+      fn = node["reference"]
+      tid = get_table_ancestor_id(node)
+      make_table_footnote_link(out, tid + fn, fn)
+      # do not output footnote text if we have already seen it for this table
+      return if @seen_footnote.include?(tid + fn)
+      @in_footnote = true
+      out.fn do |a|
+        a << make_table_footnote_text(node, tid + fn, fn)
+      end
+      @in_footnote = false
+      @seen_footnote << (tid + fn)
+    end
+
+    def make_table_footnote_link(out, fnid, fnref)
+      out << " [#{fnref}]"
+    end
+
+    def make_table_footnote_text(node, fnid, fnref)
+      first = node.first_element_child
+      noko do |xml|
+        xml.t **attr_code(anchor: first ? first["id"] : nil) do |div|
+          div << "[#{fnref}]  "
+          first.name == "p" and first.children.each { |n| parse(n, div) }
+        end
+        first.name == "p" and
+          node.elements.drop(1).each { |n| parse(n, xml) } or
+          node.children.each { |n| parse(n, xml) }
+      end.join
+    end
+
+    def get_table_ancestor_id(node)
+      table = node.ancestors("table") || node.ancestors("figure")
+      return UUIDTools::UUID.random_create.to_s if table.empty?
+      table.last["id"]
+    end
+  end
+end

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

@@ -0,0 +1,236 @@
+require "sterile"
+
+module IsoDoc::Ietf
+  class RfcConvert < ::IsoDoc::Convert
+    def make_front(out, isoxml)
+      info(isoxml, out)
+      out.front do |front|
+        title isoxml, front
+        seriesinfo isoxml, front
+        author isoxml, front
+        date isoxml, front
+        area isoxml, front
+        workgroup isoxml, front
+        keyword isoxml, front
+        abstract isoxml, front
+        note isoxml, front
+        boilerplate isoxml, front
+      end
+    end
+
+    def info(isoxml, out)
+      @meta.areas isoxml, out
+      super
+    end
+
+    def output_if_translit(text)
+      return nil if text.nil?
+      text.transliterate != text ? text.transliterate : nil
+    end
+
+    def title(isoxml, front)
+      title = @meta.get[:doctitle] or return
+      front.title title, **attr_code(abbrev: @meta.get[:docabbrev],
+                                     ascii: (@meta.get[:docascii] ||
+                                     output_if_translit(title)))
+    end
+
+    def seriesinfo(isoxml, front)
+      rfc_seriesinfo(isoxml, front) if @meta.get[:doctype] == "Rfc"
+      id_seriesinfo(isoxml, front) if @meta.get[:doctype] == "Internet Draft"
+    end
+
+    def seriesinfo_attr(isoxml)
+      attr_code(value: @meta.get[:docnumber] || "",
+                asciiValue: output_if_translit(@meta.get[:docnumber]),
+                status: @meta.get[:stage],
+                stream: isoxml&.at(ns("//bibdata/series[@type = 'stream']/"\
+                                      "title"))&.text)
+    end
+
+    def rfc_seriesinfo(isoxml, front)
+      front.seriesInfo **seriesinfo_attr(isoxml).merge({name: "RFC",
+                                                        asciiName: "RFC"})
+      i = isoxml&.at(ns("//bibdata/series[@type = 'intended']")) and
+        front.seriesInfo nil,
+        **attr_code(name: "", status: i&.at(ns("./title"))&.text,
+                    value: i&.at(ns("./number"))&.text || "")
+    end
+
+    def id_seriesinfo(isoxml, front)
+      front.seriesInfo nil,
+        **seriesinfo_attr(isoxml).merge({name: "Internet-Draft",
+                                         asciiName: "Internet-Draft"})
+      i = isoxml&.at(ns("//bibdata/series[@type = 'intended']/title"))&.text and
+        front.seriesInfo **attr_code(name: "", value: "", status: i)
+    end
+
+    def author(isoxml, front)
+      isoxml.xpath(("//xmlns:bibdata/xmlns:contributor[xmlns:role/@type = "\
+                    "'author' or xmlns:role/@type = 'editor']")).each do |c|
+        role = c.at(ns("./role/@type")).text == "editor" ? "editor" : nil
+        c.at("./organization") and org_author(c, role, front) or
+          person_author(c, role, front)
+      end
+    end
+
+    def person_author_attrs(c, role)
+      return {} if c.nil?
+      full = c&.at(ns("./completename"))&.text
+      init = c&.at(ns("./initial"))&.text ||
+        c&.xpath(ns("./forename")).map { |n| n.text[0] }.join(".")
+      init = nil if init.empty?
+      ret = attr_code(role: role, fullname: full, initials: init,
+                      surname: c&.at(ns("./surname"))&.text)
+      pers_author_attrs1(ret, full, init, c)
+    end
+
+    def pers_author_attrs1(ret, full, init, c)
+      full and ret.merge!(attr_code(
+        asciiFullname: output_if_translit(full),
+        asciiInitials: output_if_translit(init),
+        asciiSurname: output_if_translit(c&.at(ns("./surname")))))
+      ret
+    end
+
+    def person_author(c, role, front)
+      front.author **person_author_attrs(c.at(ns("./person/name")), role) do |a|
+        org = c.at(ns("./person/affiliation/organization")) and
+          organization(org, a, c.document.at(ns("//showOnFrontPage")))
+        address(c.xpath(ns(".//address")),
+                c.at(ns(".//phone[not(@type = 'fax')]")),
+                c.at(ns(".//phone[@type = 'fax']")),
+                c.xpath(ns(".//email")), c.xpath(ns(".//uri")), a)
+      end
+    end
+
+    def org_author(c, role, front)
+      front.author **attr_code(role: role) do |a|
+        organization(c.at(ns("./organization")), a,
+                     c.document.at(ns("//showOnFrontPage")))
+        address(c.at(ns(".//address")),
+                c.at(ns(".//phone[not(@type = 'fax')]")),
+                c.at(ns(".//phone[@type = 'fax']")),
+                c.at(ns(".//email")), c.at(ns(".//uri")), a)
+      end
+    end
+
+    def organization(org, out, show)
+      name = org.at(ns("./name"))&.text
+      out.organization name, **attr_code(
+        showOnFrontPage: show&.text, ascii: output_if_translit(name),
+        asciiAbbrev: output_if_translit(org.at(ns("./abbreviation"))),
+        abbrev: org.at(ns("./abbreviation")))
+    end
+
+    def address(addr, phone, fax, email, uri, out)
+      return unless addr || phone || fax || email || uri
+      out.address do |a|
+        addr and postal(addr, a)
+        phone and a.phone phone.text
+        fax and a.facsimile fax.text
+        email and email(email, a)
+        uri and a.uri uri.text
+      end
+    end
+
+    def postal(addr, out)
+      if line = addr.at(ns("./formattedAddress"))
+        line.text.split(/\n/).each do |l|
+          out.postalLine l, **attr_code(ascii: l.transliterate)
+        end
+      else
+        out.postal do |p|
+          postal_detailed(addr, p)
+        end
+      end
+    end
+
+    def postal_detailed(addr, out)
+      addr.xpath(ns("./street")).each do |s|
+        out.street s.text, **attr_code(ascii: s.text.transliterate)
+      end
+      s = addr.at(ns("./city")) and
+        out.city s.text, **attr_code(ascii: s.text.transliterate)
+      s = addr.at(ns("./state")) and
+        out.region s.text, **attr_code(ascii: s.text.transliterate)
+      s = addr.at(ns("./country")) and
+        out.country s.text, **attr_code(ascii: s.text.transliterate)
+      s = addr.at(ns("./postcode")) and
+        out.code s.text, **attr_code(ascii: s.text.transliterate)
+    end
+
+    def email(email, out)
+      ascii = email.text.transliterate
+      out.email email.text,
+        **attr_code(ascii: ascii == email.text ? nil : ascii )
+    end
+
+    def date(isoxml, front)
+      date = @meta.get[:publisheddate] || @meta.get[:circulateddate] || return
+      date = date.gsub(/T.*$/, "")
+      attr = date_attr(date) || return
+      front.date **attr_code(attr)
+    end
+
+    def date_attr(date)
+      return nil if date.nil?
+      if date.length == 4 && date =~ /^\d\d\d\d$/ then { year: date }
+      elsif date =~ /^\d\d\d\d-?\d\d$/
+        m = /^(?<year>\d\d\d\d)-(?<month>\d\d)$/.match date
+        { month: Date::MONTHNAMES[(m[:month]).to_i], year: m[:year] }
+      else
+        begin
+          d = Date.iso8601 date
+          { day: d.day.to_s.gsub(/^0/, ""), year: d.year,
+            month: Date::MONTHNAMES[d.month] }
+        rescue
+          nil
+        end
+      end
+    end
+
+    def area(isoxml, front)
+      @meta.get[:areas].each do |w|
+        front.area w
+      end
+    end
+
+    def workgroup(isoxml, front)
+      @meta.get[:wg].each do |w|
+        front.workgroup w
+      end
+    end
+
+    def keyword(isoxml, front)
+      @meta.get[:keywords].each do |kw|
+        front.keyword kw
+      end
+    end
+
+    def abstract(isoxml, front)
+      a = isoxml.at(ns("//preface/abstract | //preface/foreword")) || return
+      front.abstract **attr_code(anchor: a["id"]) do |abs|
+        a.children.reject { |c1| %w(title note).include? c1.name }.each do |c1|
+          parse(c1, abs)
+        end
+      end
+    end
+
+    def note(isoxml, front)
+      a = isoxml.at(ns("//preface/abstract/note | //preface/foreword/note")) or
+        return
+      front.note **attr_code(removeInRFC: a["removeInRFC"]) do |n|
+        title = a.at(ns("./name")) and n.name do |t|
+          title.children.each { |tt| parse(tt, t) }
+        end
+        a.children.reject { |c1| c1.name == "name" }.each do |c1|
+          parse(c1, n)
+        end
+      end
+    end
+
+    def boilerplate(isoxml, front)
+    end
+  end
+end