metanorma-cli 1.3.3.1 → 1.3.4

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

@@ -0,0 +1,167 @@
+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 pagebreak_parse(_node, _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 get_linkend(node)
+      contents = node.children.select { |c| !%w{locality localityStack}.include? c.name }.
+        select { |c| !c.text? || /\S/.match(c) }
+      !contents.empty? and
+        return Nokogiri::XML::NodeSet.new(node.document, contents).to_xml
+      ""
+    end
+
+    def eref_parse(node, out)
+      linkend = node.children.reject { |c| %w{locality localityStack}.include? c.name }
+      relative = node["relative"] ||
+        node.at(ns(".//locality[@type = 'anchor']/referenceFrom"))&.text || ""
+      section = eref_clause(node.xpath(ns("./locality | ./localityStack")), nil) || ""
+      section = "" if relative.empty?
+      out.relref **attr_code(target: node["bibitemid"], section: section,
+                             relative: relative,
+                             displayFormat: node["displayFormat"]) do |l|
+                               linkend.each { |n| parse(n, l) }
+                             end
+    end
+
+    def eref_clause(refs, target)
+      ret = []
+      ret1 = ""
+      refs.each do |l|
+        if l.name == "localityStack"
+          ret << ret1
+          ret1 = ""
+          ret << eref_clause1(l.elements, target)
+        else
+          ret1 += eref_clause1([l], target)
+        end
+      end
+      ret << ret1
+      ret.reject { |c| c.nil? || c.empty? }.join("; ")
+    end
+
+    def eref_clause1(refs, target)
+      refs.each do |l|
+        next unless %w(clause section).include? l["type"]
+        return l&.at(ns("./referenceFrom"))&.text
+      end
+      return ""
+    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/gems/ruby/2.6.0/gems/metanorma-ietf-2.2.0/lib/isodoc/ietf/metadata.rb

@@ -0,0 +1,54 @@
+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 instance)
+        # = item describedby convertedfrom alternate
+      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/gems/ruby/2.6.0/gems/metanorma-ietf-2.2.0/lib/isodoc/ietf/references.rb

@@ -0,0 +1,148 @@
+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"))
+      target = nil
+      uris&.each do |u|
+        if u["type"] == "src" then
+          target = u.text
+        end
+      end
+      list.reference **attr_code(target: target,
+                                 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&.each do |u|
+          r.format nil, **attr_code(target: u.text, type: u["type"])
+        end
+        docidentifiers = b.xpath(ns("./docidentifier"))
+        id = render_identifier(bibitem_ref_code(b))
+        !id[1].nil? and id[1] != "(NO ID)" and
+          r.refcontent id[1]
+        docidentifiers&.each do |u|
+          if %w(DOI IETF).include? u["type"]
+            r.seriesInfo nil, **attr_code(value: u.text, name: u["type"])
+          end
+        end
+      end
+    end
+
+    def relaton_to_title(b, f)
+      title = b&.at(ns("./title")) || b&.at(ns("./formattedref")) or return
+      f.title do |t|
+        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|
+          if k.at(ns("./p"))
+            k.children.each { |n| parse(n, abstract) }
+          else
+            abstract.t do |t|
+              k.children.each { |n| parse(n, t) }
+            end
+          end
+        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)
+      return false if !@xinclude
+      url = b.at(ns("./uri[@type = 'xml']")) or return false
+      /xml2rfc\.tools\.ietf\.org/.match(url)
+    end
+  end
+end

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

@@ -0,0 +1,79 @@
+module IsoDoc::Ietf
+  class RfcConvert < ::IsoDoc::Convert
+    def recommendation_labels(node)
+      [node.at(ns("./label")), node.at(ns("./title")), 
+       @xrefs.anchor(node['id'], :label, false)]
+    end
+
+    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, @i18n.recommendation)
+      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, @i18n.requirement)
+      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, @i18n.permission)
+      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
+