metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/metanorma-ietf-2.2.0/lib/asciidoctor/ietf/reqt.rng

@@ -0,0 +1,194 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<grammar xmlns="http://relaxng.org/ns/structure/1.0" datatypeLibrary="http://www.w3.org/2001/XMLSchema-datatypes">
+  <!--
+    Presupposes isodoc.rnc, is included in it
+    include "isodoc.rnc" { }
+  -->
+  <define name="requirement">
+    <element name="requirement">
+      <ref name="RequirementType"/>
+    </element>
+  </define>
+  <define name="recommendation">
+    <element name="recommendation">
+      <ref name="RequirementType"/>
+    </element>
+  </define>
+  <define name="permission">
+    <element name="permission">
+      <ref name="RequirementType"/>
+    </element>
+  </define>
+  <define name="RequirementType">
+    <optional>
+      <attribute name="obligation">
+        <ref name="ObligationType"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="unnumbered">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="number"/>
+    </optional>
+    <optional>
+      <attribute name="subsequence"/>
+    </optional>
+    <optional>
+      <attribute name="keep-with-next">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="keep-lines-together">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <attribute name="id">
+      <data type="ID"/>
+    </attribute>
+    <optional>
+      <attribute name="filename"/>
+    </optional>
+    <optional>
+      <attribute name="model"/>
+    </optional>
+    <optional>
+      <attribute name="type"/>
+    </optional>
+    <optional>
+      <ref name="reqtitle"/>
+    </optional>
+    <optional>
+      <ref name="label"/>
+    </optional>
+    <optional>
+      <ref name="subject"/>
+    </optional>
+    <zeroOrMore>
+      <ref name="reqinherit"/>
+    </zeroOrMore>
+    <zeroOrMore>
+      <ref name="classification"/>
+    </zeroOrMore>
+    <zeroOrMore>
+      <choice>
+        <ref name="measurementtarget"/>
+        <ref name="specification"/>
+        <ref name="verification"/>
+        <ref name="import"/>
+        <ref name="description"/>
+      </choice>
+    </zeroOrMore>
+    <optional>
+      <ref name="reqt_references"/>
+    </optional>
+    <zeroOrMore>
+      <choice>
+        <ref name="requirement"/>
+        <ref name="recommendation"/>
+        <ref name="permission"/>
+      </choice>
+    </zeroOrMore>
+  </define>
+  <define name="reqtitle">
+    <element name="title">
+      <ref name="FormattedString"/>
+    </element>
+  </define>
+  <define name="label">
+    <element name="label">
+      <text/>
+    </element>
+  </define>
+  <define name="subject">
+    <element name="subject">
+      <text/>
+    </element>
+  </define>
+  <define name="reqinherit">
+    <element name="inherit">
+      <text/>
+    </element>
+  </define>
+  <define name="measurementtarget">
+    <element name="measurement-target">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="specification">
+    <element name="specification">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="verification">
+    <element name="verification">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="import">
+    <element name="import">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="description">
+    <element name="description">
+      <ref name="RequirementSubpart"/>
+    </element>
+  </define>
+  <define name="reqt_references">
+    <element name="references">
+      <oneOrMore>
+        <ref name="bibitem"/>
+      </oneOrMore>
+    </element>
+  </define>
+  <define name="RequirementSubpart">
+    <optional>
+      <attribute name="type"/>
+    </optional>
+    <optional>
+      <attribute name="exclude">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="keep-with-next">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <optional>
+      <attribute name="keep-lines-together">
+        <data type="boolean"/>
+      </attribute>
+    </optional>
+    <oneOrMore>
+      <ref name="BasicBlock"/>
+    </oneOrMore>
+  </define>
+  <define name="ObligationType">
+    <choice>
+      <value>requirement</value>
+      <value>recommendation</value>
+      <value>permission</value>
+    </choice>
+  </define>
+  <define name="classification">
+    <element name="classification">
+      <ref name="classification_tag"/>
+      <ref name="classification_value"/>
+    </element>
+  </define>
+  <define name="classification_tag">
+    <element name="tag">
+      <text/>
+    </element>
+  </define>
+  <define name="classification_value">
+    <element name="value">
+      <text/>
+    </element>
+  </define>
+</grammar>

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

@@ -0,0 +1,84 @@
+module Asciidoctor
+  module Ietf
+    class Converter < ::Asciidoctor::Standoc::Converter
+      def content_validate(doc)
+        super
+        image_validate(doc)
+        workgroup_validate(doc)
+      end
+
+      def image_validate(doc)
+        doc.xpath("//image").each do |i|
+          next if i["mimetype"] == "image/svg+xml"
+          @log.add("MIME", i, "image #{i['src'][0, 40]} is not SVG!")
+        end
+      end
+
+      def workgroup_validate(doc)
+        return if @workgroups.empty?
+        doc.xpath("//bibdata/ext/editorialgroup/workgroup").each do |wg|
+          wg_norm = wg.text.sub(/ (Working|Research) Group$/, "")
+          next if @workgroups.include?(wg_norm)
+          @log.add("Document Attributes", nil, "IETF: unrecognised working group #{wg.text}")
+        end
+      end
+
+      def validate(doc)
+        content_validate(doc)
+        schema_validate(formattedstr_strip(doc.dup),
+                        File.join(File.dirname(__FILE__), "ietf.rng"))
+      end
+
+      def open_wg_cache(node)
+        wgcache_name = "#{Dir.home}/.metanorma-ietf-workgroup-cache.json"
+        node.attr("flush-caches") == "true" and FileUtils.rm wgcache_name, :force => true
+        wg = []
+        if Pathname.new(wgcache_name).file?
+          begin
+            File.open(wgcache_name, "r") { |f| wg = JSON.parse(f.read) }
+          rescue Exception => e
+            STDERR.puts "Cache #{wgcache_name} is invalid, drop it"
+          end
+        end
+        [wg, wgcache_name]
+      end
+
+      def cache_workgroup_ietf(wg, b)
+        STDERR.puts "Reading workgroups from https://tools.ietf.org/wg/..."
+        Kernel.open("https://tools.ietf.org/wg/") do |f|
+          f.each_line do |line|
+            line.scan(%r{<td width="50%" style='padding: 0 1ex'>([^<]+)</td>}) do |w|
+              wg << w[0].gsub(/\s+$/, "").gsub(/ Working Group$/, "")
+            end
+          end
+        end
+        wg
+      end
+
+      def cache_workgroup_irtf(wg, b)
+        STDERR.puts "Reading workgroups from https://irtf.org/groups..."
+        Kernel.open("https://irtf.org/groups", ssl_verify_mode: OpenSSL::SSL::VERIFY_NONE) do |f|
+          f.each_line do |line|
+            line.scan(%r{<a title="([^"]+) Research Group"[^>]+>([^<]+)<}) do |w|
+              wg << w[0].gsub(/\s+$/, "")
+              wg << w[1].gsub(/\s+$/, "") # abbrev
+            end
+          end
+        end
+        wg
+      end
+
+      def cache_workgroup(node)
+        wg, wgcache_name = open_wg_cache(node)
+        if wg.empty?
+          File.open(wgcache_name, "w") do |b|
+            wg = cache_workgroup_ietf(wg, b)
+            wg = cache_workgroup_irtf(wg, b)
+            b << wg.to_json
+          end
+        end
+        wg
+      end
+    end
+  end
+end

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

@@ -0,0 +1,227 @@
+module IsoDoc::Ietf
+  class RfcConvert < ::IsoDoc::Convert
+    def para_attrs(node)
+      { keepWithNext: node["keep-with-next"],
+        keepWithPrevious: node["keep-with-previous"],
+        anchor: node["id"] }
+    end
+
+    def para_parse(node, out)
+      out.t **attr_code(para_attrs(node)) do |p|
+        unless @termdomain.empty?
+          p << "&lt;#{@termdomain}&gt; "
+          @termdomain = ""
+        end
+        node.children.each { |n| parse(n, p) unless n.name == "note" }
+      end
+      node.xpath(ns("./note")).each { |n| parse(n, out) }
+    end
+
+    # NOTE ignoring "bare" attribute, which is tantamount to "empty"
+    def ul_attrs(node)
+      { anchor: node["id"],
+        empty: node["nobullet"],
+        spacing: node["spacing"] }
+    end
+
+    def ul_parse(node, out)
+      out.ul **attr_code(ul_attrs(node)) do |ul|
+        node.children.each { |n| parse(n, ul) }
+      end
+    end
+
+    OL_STYLE = {
+      arabic: "1",
+      roman: "i",
+      alphabet: "a",
+      roman_upper: "I",
+      alphabet_upper: "A",
+    }.freeze
+
+    def ol_style(type)
+      OL_STYLE[type&.to_sym] || type
+    end
+
+    def ol_attrs(node)
+      { anchor: node["id"], 
+        spacing: node["spacing"],
+        type: ol_style(node["type"]),
+        group: node["group"],
+        start: node["start"] }
+    end
+
+    def ol_parse(node, out)
+      out.ol **attr_code(ol_attrs(node)) do |ol|
+        node.children.each { |n| parse(n, ol) }
+      end
+    end
+
+    def dl_attrs(node)
+      attr_code(anchor: node["id"],
+                newline: node["newline"],
+                indent: node["indent"],
+                spacing: node["spacing"])
+    end
+
+    def dt_parse(dt, term)
+      if dt.elements.empty?
+        term << dt.text
+      else
+        dt.children.each { |n| parse(n, term) }
+      end
+    end
+
+    def note_label(node)
+      n = @xrefs.get[node["id"]]
+      return l10n("#{@i18n.note}: ") if n.nil? || n[:label].nil? || n[:label].empty?
+      l10n("#{@i18n.note} #{n[:label]}: ")
+    end
+
+    def note_parse(node, out)
+      first = node.first_element_child
+      out.aside **attr_code(anchor: node["id"] || first["id"]) do |a|
+        a.t do |p|
+          p << note_label(node)
+          first.name == "p" and first.children.each { |n| parse(n, p) }
+        end
+        first.name == "p" and
+          node.elements.drop(1).each { |n| parse(n, out) } or
+          node.children.each { |n| parse(n, out) }
+      end
+    end
+
+    def example_parse(node, out)
+      example_label(node, out, node.at(ns("./name")))
+      node.elements.each { |n| parse(n, out) unless n.name == "name" }
+    end
+
+    def example_label(node, div, name)
+      n = @xrefs.get[node["id"]]
+      div.t **attr_code(anchor: node["id"], keepWithNext: "true") do |p|
+        lbl = (n.nil? || n[:label].nil? || n[:label].empty?) ? @i18n.example :
+          l10n("#{@i18n.example} #{n[:label]}")
+        p << lbl
+        name and !lbl.nil? and p << ": "
+        name and name.children.each { |n| parse(n, p) }
+      end
+    end
+
+    def sourcecode_parse(node, out)
+      out.figure **attr_code(anchor: node["id"]) do |div|
+        name = node&.at(ns("./name"))&.remove and div.name do |n|
+          name.children.each { |nn| parse(nn, n) }
+        end
+        div.sourcecode **attr_code(type: node["lang"], name: node["filename"],
+                                   markers: node["markers"],
+                                   src: node["src"]) do |s|
+                                     node.children.each { |x| parse(x, s) unless x.name == "name" }
+                                   end
+      end
+    end
+
+    def pre_parse(node, out) 
+      out.artwork **attr_code(anchor: node["id"], align: node["align"],
+                              alt: node["alt"], type: "ascii-art") do |s|
+        s.cdata node.text.sub(/^\n/, "").gsub(/\t/, "    ")
+      end
+    end
+
+    def annotation_parse(node, out)
+      @sourcecode = false
+      @annotation = true
+      node.at("./preceding-sibling::*[local-name() = 'annotation']") or
+        out << "\n\n"
+      callout = node.at(ns("//callout[@target='#{node['id']}']"))
+      out << "\n&lt;#{callout.text}&gt; "
+      out << node&.children&.text&.strip
+      @annotation = false
+    end
+
+    def formula_where(dl, out)
+      return unless dl
+      out.t { |p| p << @i18n.where }
+      parse(dl, out)
+    end
+
+    def formula_parse1(node, out)
+      out.t **attr_code(anchor: node["id"]) do |p|
+        parse(node.at(ns("./stem")), p)
+        lbl = @xrefs.anchor(node['id'], :label, false)
+        lbl.nil? or
+          p << "    (#{lbl})"
+      end
+    end
+
+    def formula_parse(node, out)
+      formula_parse1(node, out)
+      formula_where(node.at(ns("./dl")), out)
+      node.children.each do |n|
+        next if %w(stem dl).include? n.name
+        parse(n, out)
+      end
+    end
+
+    def quote_attribution(node)
+      author = node&.at(ns("./author"))&.text
+      source = node&.at(ns("./source/@uri"))&.text
+      attr_code(quotedFrom: author, cite: source)
+    end
+
+    def quote_parse(node, out)
+      out.blockquote **quote_attribution(node) do |p|
+        node.children.each do |n|
+          parse(n, p) unless ["author", "source"].include? n.name
+        end
+      end
+    end
+
+    def admonition_name_parse(_node, div, name)
+      div.t **{keepWithNext: "true" } do |p|
+        name.children.each { |n| parse(n, p) }
+      end
+    end
+
+    def admonition_parse(node, out)
+      type = node["type"]
+      name = admonition_name(node, type)
+      out.aside **{ anchor: node["id"] } do |t|
+        admonition_name_parse(node, t, name) if name
+        node.children.each { |n| parse(n, t) unless n.name == "name" }
+      end
+    end
+
+    def review_note_parse(node, out)
+      out.cref **attr_code(anchor: node["id"], display: node["display"],
+                           source: node["reviewer"]) do |c|
+        name = node.at(ns("./name")) and c.name do |div|
+          name.children.each { |n| parse(n, div) }
+        end
+        node.children.each { |n| parse(n, c) unless n.name == "name" }
+      end
+    end
+
+    def figure_name_parse(node, div, name)
+      return if name.nil?
+      div.name do |n|
+        name.children.each { |n| parse(n, div) }
+      end
+    end
+
+    def pseudocode_parse(node, out)
+      sourcecode_parse(node, out)
+    end
+
+    def figure_parse(node, out)
+      return pseudocode_parse(node, out) if node["class"] == "pseudocode" ||
+        node["type"] == "pseudocode"
+      @in_figure = true
+      out.figure **attr_code(anchor: node["id"]) do |div|
+        figure_name_parse(node, div, node.at(ns("./name")))
+        node.children.each do |n|
+          parse(n, div) unless n.name == "name"
+        end
+      end
+      @in_figure = false
+    end
+  end
+end