metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/metanorma-nist-1.2.0/lib/asciidoctor/nist/boilerplate.rb

@@ -0,0 +1,107 @@
+module Asciidoctor
+  module NIST
+    class Converter < Standoc::Converter
+      SERIES = {
+        "nist-ams": "NIST Advanced Manufacturing Series",
+        "building-science": "NIST Building Science Series",
+        "nist-fips": "NIST Federal Information Processing Standards",
+        "nist-gcr": "NIST Grant/Contract Reports",
+        "nist-hb": "NIST Handbook",
+        "itl-bulletin": "ITL Bulletin",
+        "jpcrd": "Journal of Physical and Chemical Reference Data",
+        "nist-jres": "NIST Journal of Research",
+        "letter-circular": "NIST Letter Circular",
+        "nist-monograph": "NIST Monograph",
+        "nist-ncstar": "NIST National Construction Safety Team Act Reports",
+        "nist-nsrds": "NIST National Standard Reference Data Series",
+        "nistir": "NIST Interagency/Internal Report",
+        "product-standards": "NIST Product Standards",
+        "nist-sp": "NIST Special Publication",
+        "nist-tn": "NIST Technical Note",
+        "other": "NIST Other",
+        "csrc-white-paper": "CSRC White Paper",
+        "csrc-book": "CSRC Book",
+        "csrc-use-case": "CSRC Use Case",
+        "csrc-building-block": "CSRC Building Block",
+        "nist-cswp": "NIST Cybersecurity White Paper",
+      }.freeze
+
+      SERIES_ABBR = {
+        "nist-ams": "NIST AMS",
+        "building-science": "NIST Building Science Series",
+        "nist-fips": "NIST FIPS",
+        "nist-gcr": "NISTGCR",
+        "nist-hb": "NIST HB",
+        "itl-bulletin": "ITL Bulletin",
+        "jpcrd": "JPCRD",
+        "nist-jres": "NIST JRES",
+        "letter-circular": "NIST Letter Circular",
+        "nist-monograph": "NIST MN",
+        "nist-ncstar": "NIST NCSTAR",
+        "nist-nsrds": "NIST NSRDS",
+        "nistir": "NISTIR",
+        "product-standards": "NIST Product Standards",
+        "nist-sp": "NIST SP",
+        "nist-tn": "NIST TN",
+        "other": "NIST Other",
+        "csrc-white-paper": "CSRC White Paper",
+        "csrc-book": "CSRC Book",
+        "csrc-use-case": "CSRC Use Case",
+        "csrc-building-block": "CSRC Building Block",
+        "nist-cswp": "NIST CSWP",
+      }.freeze
+
+      CALL_FOR_PATENT_CLAIMS = <<~END.freeze
+      <clause><title>Call for Patent Claims</title>
+      <p>This public review includes a call for information on essential patent claims (claims whose use would be required for compliance with the guidance or requirements in this Information Technology Laboratory (ITL) draft publication). Such guidance and/or requirements may be directly stated in this ITL Publication or by reference to another publication. This call also includes disclosure, where known, of the existence of pending U.S. or foreign patent applications relating to this ITL draft publication and of any relevant unexpired U.S. or foreign patents.</p>
+
+<p>ITL may require from the patent holder, or a party authorized to make assurances on its behalf, in written or electronic form, either:</p>
+
+<ol type="arabic"><li><p>assurance in the form of a general disclaimer to the effect that such party does not hold and does not currently intend holding any essential patent claim(s); or</p></li>
+
+<li><p>assurance that a license to such essential patent claim(s) will be made available to applicants desiring to utilize the license for the purpose of complying with the guidance or requirements in this ITL draft publication either:</p>
+
+        <ol type="roman"><li><p>under reasonable terms and conditions that are demonstrably free of any unfair discrimination; or</p></li>
+
+        <li><p>without compensation and under reasonable terms and conditions that are demonstrably free of any unfair discrimination.</p></li></ol>
+</li></ol>
+
+<p>Such assurance shall indicate that the patent holder (or third party authorized to make assurances on its behalf) will include in any documents transferring ownership of patents subject to the assurance, provisions sufficient to ensure that the commitments in the assurance are binding on the transferee, and that the transferee will similarly include appropriate provisions in the event of future transfers with the goal of binding each successor-in-interest.</p>
+
+<p>The assurance shall also indicate that it is intended to be binding on successors-in-interest regardless of whether such provisions are included in the relevant transfer documents.</p>
+
+<p>Such statements should be addressed to: ITL-POINT-OF_CONTACT.</p>
+</clause>
+      END
+
+      PATENT_DISCLOSURE_NOTICE1 = <<~END.freeze
+            <clause><title>Patent Disclosure Notice</title>
+      <p>NOTICE: The Information Technology Laboratory (ITL) has requested that holders of patent claims whose use may be required for compliance with the guidance or requirements of this publication disclose such patent claims to ITL. However, holders of patents are not obligated to respond to ITL calls for patents and ITL has not undertaken a patent search in order to identify which, if any, patents may apply to this publication. </p>
+<p>Following the ITL call for the identification of patent claims whose use may be required for compliance with the guidance or requirements of this publication, notice of one or more such claims has been received. </p>
+<p>By publication, no position is taken by ITL with respect to the validity or scope of any patent claim or of any rights in connection therewith. The known patent holder(s) has (have), however, provided to NIST a letter of assurance stating either (1) a general disclaimer to the effect that it does (they do) not hold and does (do) not currently intend holding any essential patent claim(s), or (2) that it (they) will negotiate royalty-free or royalty-bearing licenses with other parties on a demonstrably nondiscriminatory basis with reasonable terms and conditions. </p>
+<p>Details may be obtained from ITL-POINT-OF_CONTACT. </p>
+<p>No representation is made or implied that this is the only license that may be required to avoid patent infringement in the use of this publication. </p>
+</clause>
+      END
+
+      PATENT_DISCLOSURE_NOTICE2 = <<~END.freeze
+            <clause><title>Patent Disclosure Notice</title>
+      <p>NOTICE: ITL has requested that holders of patent claims whose use may be required for compliance with the guidance or requirements of this publication disclose such patent claims to ITL. However, holders of patents are not obligated to respond to ITL calls for patents and ITL has not undertaken a patent search in order to identify which, if any, patents may apply to this publication.</p>
+<p>As of the date of publication and following call(s) for the identification of patent claims whose use may be required for compliance with the guidance or requirements of this publication, no such patent claims have been identified to ITL.</p>
+<p>No representation is made or implied by ITL that licenses are not required to avoid patent infringement in the use of this publication.</p>
+</clause>
+      END
+
+      def boilerplate_isodoc(xmldoc)
+        conv = super
+        conv.i18n.set(:nist_division, @nistdivision)
+        conv.i18n.set(:nist_division_address, @nistdivisionaddress)
+        conv
+      end
+
+      def boilerplate_file(xmldoc)
+        File.join(@libdir, @series == "nist-cswp" ? "nist_intro_cswp.xml" : "nist_intro.xml")
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-nist-1.2.0/lib/asciidoctor/nist/cleanup.rb

@@ -0,0 +1,206 @@
+module Asciidoctor
+  module NIST
+    class Converter < Standoc::Converter
+      def cleanup(xmldoc)
+        sourcecode_cleanup(xmldoc)
+        annex_rename(xmldoc)
+        super
+      end
+
+      def annex_rename(xmldoc)
+        return unless xmldoc.xpath("//references").size == 1
+        replace_title(xmldoc, "//annex[references]", @i18n&.normref, true)
+      end
+
+      def sourcecode_cleanup(xmldoc)
+        xmldoc.xpath("//sourcecode").each do |x|
+          x.traverse do |n|
+            next unless n.text?
+            n.replace(Nokogiri::XML::NodeSet.new(n.document,
+                                                 nistvariable_insert(n)))
+          end
+        end
+      end
+
+      # skip annex/terms/terms, which is empty node
+      def termdef_subclause_cleanup(xmldoc)
+        xmldoc.xpath("//terms[terms]").each do |t|
+          next if t.parent.name == "terms"
+          t.children.each { |n| n.parent = t.parent }
+          t.remove
+        end
+      end
+
+      def sections_cleanup(x)
+        super
+        x.xpath("//*[@inline-header]").each do |h|
+          h.delete("inline-header")
+        end
+      end
+
+      def move_clauses_into_preface(x, preface)
+        move_clauses_into_preface1(x, preface)
+        move_execsummary_into_preface(x, preface)
+      end
+
+      def move_clauses_into_preface1(x, preface)
+        x.xpath("//clause[@preface]").each do |c|
+          c.delete("preface")
+          title = c&.at("./title")&.text.downcase
+          c.name = "reviewernote" if title == "note to reviewers"
+          c.name = "executivesummary" if title == "executive summary"
+          preface.add_child c.remove
+        end
+      end
+
+      def move_execsummary_into_preface(x, preface)
+        x.xpath("//clause[@executivesummary]").each do |c|
+          c.delete("executivesummary")
+          title = c&.at("./title")&.text.downcase
+          c.name = "executivesummary"
+          preface.add_child c.remove
+        end
+      end
+
+      def move_sections_into_preface(x, preface)
+        foreword = x.at("//foreword") and preface.add_child foreword.remove
+        intro = x.at("//introduction") and preface.add_child intro.remove
+        move_clauses_into_preface(x, preface)
+        intro = x.at("//acknowledgements") and preface.add_child intro.remove
+        callforpatentclaims(x, preface)
+      end
+
+      def callforpatentclaims(x, preface)
+        return if @series == "nist-cswp"
+        if @callforpatentclaims
+          docemail = x&.at("//uri[@type = 'email']")&.text || "???"
+          docnumber = x&.at("//docnumber")&.text || "???"
+          status = x&.at("//bibdata/status/stage")&.text
+          published = status.nil? || /^final/.match(status)
+          preface.add_child patent_text(published, docemail, docnumber)
+        end
+      end
+
+      def patent_text(published, docemail, docnumber)
+        patent = (!published ? CALL_FOR_PATENT_CLAIMS :
+                  (@commitmenttolicence ? PATENT_DISCLOSURE_NOTICE1 :
+                   PATENT_DISCLOSURE_NOTICE2)).clone
+        patent.gsub(/ITL-POINT-OF_CONTACT/, published ?
+                    (@patentcontact || docemail) :
+                    (@patentcontact ||
+                     "#{docemail}, with the Subject: #{docnumber} "\
+                     "Call for Patent Claims"))
+      end
+
+      def make_preface(x, s)
+        preface = s.add_previous_sibling("<preface/>").first
+        move_sections_into_preface(x, preface)
+        make_abstract(x, s)
+        summ = x.at("//executivesummary") and preface.add_child summ.remove
+      end
+
+      # handle NIST references separately
+      # doc identifier format, NIST: NIST SP 800-87-1 {Vol./Volume 8}|
+      # {Rev./Revision 8}|(Month YYYY)
+      def reference_names(docxml)
+        super
+        ret = get_all_nist_refs(docxml)
+        tallies = ret.inject(Hash.new(0)) do |memo, (k, v)|
+          memo[v[:trunc]] += 1 unless v[:trunc].nil?
+          memo
+        end
+        ret.each do |k, v|
+          tallies[v[:trunc]] == 1 and @anchors[k][:xref] = v[:trunc]
+          @anchors&.dig(k, :xref)&.sub!(/^NIST /, "")
+        end
+      end
+
+      def truncate_nist_ref(text)
+        #text.sub(/\s\((January|February|March|April|May|June|July|August|
+        #                September|October|November|December)\s\d\d\d\d\).*$/x, "")
+        text
+      end
+
+      def get_all_nist_refs(docxml)
+        ret = {}
+        docxml.xpath("//bibitem[not(ancestor::bibitem)]").each do |ref|
+          #next unless ref.at("./docidentifier[@type = 'NIST']")
+          ret[ref["id"]] = {}
+          ret[ref["id"]][:xref] = ref&.at("./docidentifier[not(@type = 'DOI')]")&.text or next
+          ret[ref["id"]][:trunc] = truncate_nist_ref(ret[ref["id"]][:xref])
+        end
+        ret
+      end
+
+      TERM_CLAUSE = "//sections/terms | "\
+        "//sections/clause[descendant::terms] | "\
+        "//annex[descendant::terms]".freeze
+
+      def sort_biblio(bib)
+        @citation_order = {}
+        bib.document.xpath("//xref | //origin").each_with_index do |x, i|
+          cit = x["target"] || x["bibitemid"]
+          next unless refid? cit
+          @citation_order[cit] ||= i
+        end
+        bib.sort do |a, b|
+          sort_biblio_key(a) <=> sort_biblio_key(b)
+        end
+      end
+
+      # if numeric citation, order by appearance. if alphanumeric, sort alphabetically
+      # if identifier, zero-pad numeric component for NIST ids
+      def sort_biblio_key(bib)
+        if metaid = bib&.at("./docidentifier[@type = 'metanorma']")&.text&.gsub(%r{[\[\]]}, "")
+          key = /^\[\d+\]$/.match(metaid) ? ( @citation_order[metaid] % "09%d" ) : metaid
+        elsif metaid = bib&.at("./docidentifier[@type = 'NIST']")&.text
+          key = metaid.sub(/-(\d+)/) {|m| sprintf "-%09d", ($1.to_i) }
+        elsif metaid = bib&.at("./docidentifier[not(@type = 'DOI' or "\
+                               "@type = 'metanorma' or @type = 'ISSN' or @type = 'ISBN')]")&.text
+          key = metaid.sub(/-(\d+)/) {|m| sprintf "-%09d", ($1.to_i) }
+        else # no usable docid
+          key = "000000000" + bib["id"]
+        end
+        title = bib&.at("./title[@type = 'main']")&.text ||
+          bib&.at("./title")&.text || bib&.at("./formattedref")&.text
+        "#{key} :: #{title}"
+      end
+
+      def nistvariable_insert(n)
+        acc = []
+        n.text.split(/((?<!\{)\{{3}(?!\{)|(?<!\})\}{3}(?!\}))/).each_slice(4).
+          map do |a|
+          acc << Nokogiri::XML::Text.new(a[0], n.document)
+          next unless a.size == 4
+          acc << Nokogiri::XML::Node.new("nistvariable", n)
+          acc[-1].content = a[2]
+        end
+        acc
+      end
+
+      def section_names_refs_cleanup(x)
+        replace_title(x, "//bibliography//references[@normative = 'true']",
+                      @i18n&.normref, true)
+        replace_title(x, "//bibliography//references[@normative = 'false']",
+                      @i18n&.bibliography, true)
+      end
+
+      def section_names_terms_cleanup(x)
+        replace_title(x, "//definitions[@type = 'symbols']", @i18n&.symbols)
+        replace_title(x, "//definitions[@type = 'abbreviated_terms']", @i18n&.abbrev)
+        replace_title(x, "//definitions[not(@type)]", @i18n&.symbolsabbrev)
+        replace_title(x, "//sections//terms#{SYMnoABBR} | //sections//clause[.//terms]#{SYMnoABBR}",
+                      @i18n&.termsdefsymbols, true)
+        replace_title(x, "//sections//terms#{ABBRnoSYM} | //sections//clause[.//terms]#{ABBRnoSYM}",
+                      @i18n&.termsdefabbrev, true)
+        replace_title(x, "//sections//terms#{SYMABBR} | //sections//clause[.//terms]#{SYMABBR}",
+                      @i18n&.termsdefsymbolsabbrev, true)
+        replace_title(x, "//sections//terms#{NO_SYMABBR} | //sections//clause[.//terms]#{NO_SYMABBR}",
+                      @i18n&.termsdefsymbolsabbrev, true)
+        replace_title(
+          x, "//sections//terms[not(.//definitions)] | //sections//clause[.//terms][not(.//definitions)]",
+          @i18n&.termsdef, true)
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-nist-1.2.0/lib/asciidoctor/nist/converter.rb

@@ -0,0 +1,218 @@
+require "asciidoctor"
+require "asciidoctor/nist"
+require "asciidoctor/standoc/converter"
+require "isodoc/nist/html_convert"
+require "isodoc/nist/word_convert"
+require_relative "front"
+require_relative "boilerplate"
+require_relative "validate"
+require_relative "cleanup"
+require "fileutils"
+
+module Asciidoctor
+  module NIST
+    class Converter < Standoc::Converter
+      XML_ROOT_TAG = "nist-standard".freeze
+      XML_NAMESPACE = "https://www.metanorma.org/ns/nist".freeze
+
+      register_for "nist"
+
+      def table(node)
+        role = node.role || node.attr("style")
+        return errata(node) if role == "errata"
+        super
+      end
+
+      def errata1(node)
+        cols = []
+        node.rows[:head][-1].each { |c| cols << c.text.downcase }
+        table = []
+        node.rows[:body].each do |r|
+          row = {}
+          r.each_with_index { |c, i| row[cols[i]] = c.content.join("") }
+          table << row
+        end
+        table
+      end
+
+      def errata_row(row, entry)
+        row.date { |x| x << entry["date"] }
+        row.type { |x| x << entry["type"] }
+        row.change { |x| x << entry["change"] }
+        row.pages { |x| x << entry["pages"] }
+      end
+
+      def errata(node)
+        table = errata1(node)
+        noko do |xml|
+          xml.errata do |errata|
+            table.each do |entry|
+              errata.row do |row|
+                errata_row(row, entry)
+              end
+            end
+          end
+        end
+      end
+
+      def dlist(node)
+        role = node.role || node.attr("style")
+        return glossary(node) if role == "glossary"
+        super
+      end
+
+      def glossary(node)
+        noko do |xml|
+          xml.dl **{id: Asciidoctor::Standoc::Utils::anchor_or_uuid(node),
+                    type: "glossary"} do |xml_dl|
+            node.items.each do |terms, dd|
+              dt(terms, xml_dl)
+              dd(dd, xml_dl)
+            end
+          end
+        end.join("\n")
+      end
+
+      def makexml(node)
+        @draft = node.attributes.has_key?("draft")
+        super
+      end
+
+      def doctype(node)
+        d = node.attr("doctype")
+        d = "standard" if d == "article" # article is Asciidoctor default
+        d
+      end
+
+      def init(node)
+        @callforpatentclaims = node.attr("call-for-patent-claims")
+        @commitmenttolicence = node.attr("commitment-to-licence")
+        @patentcontact = node.attr("patent-contact")
+        @biblioasappendix = node.attr("biblio-as-appendix")
+        @nistdivision = node.attr("nist-division") ||
+          "Computer Security Division, Information Technology Laboratory"
+        @nistdivisionaddress = node.attr("nist-division-address") ||
+          "100 Bureau Drive (Mail Stop 8930) Gaithersburg, MD 20899-8930"
+        @series = node.attr("series")
+        super
+      end
+
+      def outputs(node, ret)
+        File.open(@filename + ".xml", "w:UTF-8") { |f| f.write(ret) }
+          presentation_xml_converter(node).convert(@filename + ".xml")
+          html_converter(node).convert(@filename + ".presentation.xml", 
+                                       nil, false, "#{@filename}.html")
+          doc_converter(node).convert(@filename + ".presentation.xml", 
+                                      nil, false, "#{@filename}.doc")
+          pdf_converter(node)&.convert(@filename + ".presentation.xml", 
+                                       nil, false, "#{@filename}.pdf")
+      end
+
+      def clause_parse(attrs, xml, node)
+        role = node.role || node.attr("style")
+        attrs[:executivesummary] = true if role == "executive-summary"
+        super
+      end
+
+      def acknowledgements_parse(attrs, xml, node)
+        xml.acknowledgements **attr_code(attrs) do |xml_section|
+          xml_section << node.content
+        end
+      end
+
+      def audience_parse(attrs, xml, node)
+        xml.audience **attr_code(attrs) do |xml_section|
+          xml_section << node.content
+        end
+      end
+
+      def conformancetesting_parse(attrs, xml, node)
+        xml.conformancetesting **attr_code(attrs) do |xml_section|
+          xml_section << node.content
+        end
+      end
+
+      def style(n, t)
+        return
+      end
+
+      def sectiontype_streamline(ret)
+        case ret
+        when "glossary", "terminology"
+          "terms and definitions"
+        else
+          super
+        end
+      end
+
+      def term_def_parse(attrs, xml, node, toplevel)
+        if node.attr("style") == "appendix" && node.level == 1
+          terms_annex_parse(attrs, xml, node)
+        else
+          clause_parse(attrs, xml, node)
+        end
+      end
+
+      def bibliography_parse(a, xml, node)
+        @biblioasappendix and node.level == 1 and
+          return bibliography_annex_parse(a, xml, node)
+        super
+      end
+
+      def bibliography_annex_parse(attrs, xml, node)
+        attrs1 = attrs.merge(id: "_" + UUIDTools::UUID.random_create)
+        xml.annex **attr_code(attrs1) do |xml_section|
+          xml_section.title { |t| t << node.title }
+          @biblio = true
+          xml.references **attr_code(attrs.merge(normative: true)) do |r|
+            r << node.content
+          end
+        end
+        @biblio = false
+      end
+
+      def terms_annex_parse(attrs, xml, node)
+        attrs1 = attrs.merge(id: "_" + UUIDTools::UUID.random_create)
+        xml.annex **attr_code(attrs1) do |xml_section|
+          xml_section.title { |name| name << node.title }
+          xml_section.terms **attr_code(attrs) do |terms|
+            (s = node.attr("source")) && s.split(/,/).each do |s1|
+              terms.termdocsource(nil, **attr_code(bibitemid: s1))
+            end
+            terms << node.content
+          end
+        end
+      end
+
+      NIST_PREFIX_REFS = "SP|FIPS"
+
+      def refitem(xml, item, node)
+        item.sub!(Regexp.new("^(<ref[^>]+>)\\[(#{NIST_PREFIX_REFS}) "),
+                  "\\1[NIST \\2 ")
+        super
+      end
+
+      def fetch_ref(xml, code, year, **opts)
+        code.sub!(Regexp.new("^(#{NIST_PREFIX_REFS}) "), "NIST \\1 ")
+        super
+      end
+
+      def presentation_xml_converter(node)
+        IsoDoc::NIST::PresentationXMLConvert.new(html_extract_attributes(node))
+      end
+
+      def html_converter(node)
+        IsoDoc::NIST::HtmlConvert.new(html_extract_attributes(node))
+      end
+
+      def doc_converter(node)
+        IsoDoc::NIST::WordConvert.new(doc_extract_attributes(node))
+      end
+
+      def pdf_converter(node)
+        return nil if node.attr("no-pdf")
+        IsoDoc::NIST::PdfConvert.new(html_extract_attributes(node))
+      end
+    end
+  end
+end