metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/metanorma-nist-1.2.0/lib/isodoc/nist/pdf_convert.rb

@@ -0,0 +1,22 @@
+require "isodoc"
+require "fileutils"
+require_relative "base_convert"
+
+module IsoDoc
+  module NIST
+    # A {Converter} implementation that generates PDF HTML output, and a
+    # document schema encapsulation of the document for validation
+    class PdfConvert < IsoDoc::XslfoPdfConvert
+      def initialize(options)
+        @libdir = File.dirname(__FILE__)
+        super
+      end
+
+      def pdf_stylesheet(docxml)
+        series =  docxml&.at(ns("//bibdata/series/abbreviation"))&.text
+        series == "NIST CSWP" ?  "nist.cswp.xsl" : "nist.sp.xsl"
+      end
+    end
+  end
+end
+

data/gems/ruby/2.6.0/gems/metanorma-nist-1.2.0/lib/isodoc/nist/presentation_xml_convert.rb

@@ -0,0 +1,80 @@
+require_relative "init"
+require "isodoc"
+
+module IsoDoc
+  module NIST
+    class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
+      def convert1(docxml, filename, dir)
+        info docxml, nil
+        insert_preface_sections(docxml)
+        super
+      end
+
+      def insert_preface_sections(docxml)
+        insert_keywords(docxml)
+      end
+
+      def wrap_brackets(txt)
+        return txt if /^\[.*\]$/.match txt
+        "[#{txt}]"
+      end
+
+      def get_linkend(node)
+        contents = non_locality_elems(node).select { |c| !c.text? || /\S/.match(c) }
+        return unless contents.empty?
+        link = anchor_linkend(node, docid_l10n(node["target"] ||
+                                               wrap_brackets(node['citeas'])))
+        link += eref_localities(node.xpath(ns("./locality | ./localityStack")),
+                                link)
+        non_locality_elems(node).each { |n| n.remove }
+        node.add_child(link)
+      end
+
+      def annex1(f)
+        lbl = @xrefs.anchor(f['id'], :label)
+        if t = f.at(ns("./title"))
+          t.children = "<strong>#{t.children.to_xml}</strong>"
+        end
+        prefix_name(f, " &mdash; ", lbl, "title")
+        t = f.at(ns("./title"))
+        t["xref"] = lbl.gsub(/<[^>]+>/, "")
+      end
+
+      def keyword_clause(kw)
+        <<~END
+        <clause id="_#{UUIDTools::UUID.random_create}" type="keyword">
+        <title>#{@i18n.keywords}</title>
+        #{@i18n.keywords_intro}
+        <p>#{@i18n.l10n(kw.join("; "))}</p></clause>
+        END
+      end
+
+      def insert_keywords(docxml)
+        kw = @meta.get[:keywords]
+        kw.empty? and return
+        if abstract = docxml.at(ns("//preface/abstract"))
+          abstract.next = keyword_clause(kw)
+        elsif foreword = docxml.at(ns("//preface/foreword"))
+          foreword.next = keyword_clause(kw)
+        else
+          preface_init_insert_pt(docxml)&.children&.first&.
+            add_previous_sibling(keyword_clause(kw))
+        end
+      end
+
+      def preface_init_insert_pt(docxml)
+        docxml.at(ns("//preface")) ||
+          docxml.at(ns("//sections")).
+          add_previous_sibling("<preface> </preface>").first
+      end
+
+      def clause1(f)
+        return if f.name == "references" && suppress_biblio_title(f)
+        super
+      end
+
+      include Init
+    end
+  end
+end
+

data/gems/ruby/2.6.0/gems/metanorma-nist-1.2.0/lib/isodoc/nist/refs.rb

@@ -0,0 +1,89 @@
+module IsoDoc
+  module NIST
+    module BaseConvert
+      NIST_PUBLISHER_XPATH =
+        "./contributor[xmlns:role/@type = 'publisher']/"\
+        "organization[abbreviation = 'NIST' or xmlns:name = 'NIST']".freeze
+
+      # we are taking the ref number/code out as prefix to reference
+      def nonstd_bibitem(list, b, ordinal, bibliography)
+        list.p **attr_code(iso_bibitem_entry_attrs(b, bibliography)) do |r|
+          if !b.at(ns("./formattedref"))
+            nist_reference_format(b, r)
+          else
+            reference_format(b, r)
+          end
+        end
+      end
+
+      def std_bibitem_entry(list, b, ordinal, biblio)
+        nonstd_bibitem(list, b, ordinal, biblio)
+      end
+
+      def reference_format(b, r)
+        code = render_identifier(bibitem_ref_code(b))
+        if code[0]
+          r << "#{code[0]} "
+          insert_tab(r, 1)
+        end
+        reference_format1(b, r)
+        r << " [#{code[1]}] " if code[1]
+      end
+
+      def reference_format1(b, r)
+        if ftitle = b.at(ns("./formattedref"))
+          ftitle&.children&.each { |n| parse(n, r) }
+        else
+          title = b.at(ns("./title[@language = '#{@lang}']")) || b.at(ns("./title"))
+          r.i do |i|
+            title&.children&.each { |n| parse(n, i) }
+          end
+        end
+      end
+
+      def bracket_if_num(x)
+        return nil if x.nil?
+        x = x.text.sub(/^\[/, "").sub(/\]$/, "")
+        "[#{x}]"
+      end
+
+      def omit_docid_prefix(prefix)
+        return true if prefix.nil? || prefix.empty?
+        super || prefix == "NIST"
+      end
+
+      def nist_reference_format(b, r)
+        code = render_identifier(bibitem_ref_code(b))
+        if code[0]
+          r << "#{code[0]} "
+          insert_tab(r, 1)
+        end
+        bibitem = b.dup.to_xml
+        r.parent.add_child ::Iso690Render.render(bibitem, true)
+      end
+
+      def bibliography_parse(node, out)
+        title = node&.at(ns("./title"))&.text || ""
+        out.div do |div|
+          unless suppress_biblio_title(node)
+              clause_parse_title(node, div, node.at(ns("./title")), out)
+          end
+          biblio_list(node, div, true)
+        end
+      end
+
+      def bibliography(isoxml, out)
+        f = isoxml.at(ns("//bibliography/clause | //bibliography/references")) || return
+        page_break(out)
+        isoxml.xpath(ns("//bibliography/clause | //bibliography/references")).each do |f|
+          out.div do |div|
+            div.h1 **{ class: "Section3" } do |h1|
+                f&.at(ns("./title"))&.children.each { |n| parse(n, h1) }
+            end
+            biblio_list(f, div, false)
+          end
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-nist-1.2.0/lib/isodoc/nist/render.rb

@@ -0,0 +1,255 @@
+require "nokogiri"
+require "twitter_cldr"
+require_relative "render_contributors"
+require_relative "render_dates"
+
+module Iso690Render
+=begin
+  Out of scope: Provenance (differentiating elements by @source in rendering)
+=end
+
+  def self.render(bib, embedded = false)
+    docxml = Nokogiri::XML(bib)
+    docxml.remove_namespaces!
+    parse(docxml.root, embedded)
+  end
+
+  def self.title(doc)
+    doc&.at("./title")&.text
+  end
+
+  def self.medium(doc)
+    doc&.at("./medium")&.text
+  end
+
+=begin
+  def self.edition(doc)
+    x = doc.at("./edition")
+    return "" unless x
+    return x.text unless /^\d+$/.match x.text
+    x.text.to_i.localize.to_rbnf_s("SpelloutRules", "spellout-ordinal")
+  end
+=end
+
+  def self.is_nist(doc)
+    publisher = doc&.at("./contributor[role/@type = 'publisher']/organization/name")&.text
+    abbr = doc&.at("./contributor[role/@type = 'publisher']/organization/abbreviation")&.text
+    publisher == "NIST" || abbr == "NIST" ||
+      publisher == "National Institute of Standards and Technology"
+  end
+
+  def self.placepub(doc)
+    place = doc&.at("./place")&.text
+    publisher = doc&.at("./contributor[role/@type = 'publisher']/organization/name")&.text
+    abbr = doc&.at("./contributor[role/@type = 'publisher']/organization/abbreviation")&.text
+    series = series_title(doc)
+    series == "NIST Federal Information Processing Standards" and
+      return "U.S. Department of Commerce, Washington, D.C."
+    is_nist(doc) and
+      return "National Institute of Standards and Technology, Gaithersburg, MD"
+    ret = ""
+    ret += place if place
+    ret += ": " if place && publisher
+    ret += publisher if publisher
+    ret
+  end
+
+  def self.series_title(doc)
+    s = doc.at("./series[@type = 'main']") ||
+      doc.at("./series[not(@type)]") ||
+      doc.at("./series")
+    s&.at("./title")&.text
+  end
+
+  def self.series(doc, type)
+    s = doc.at("./series[@type = 'main']") || 
+      doc.at("./series[not(@type)]") ||
+      doc.at("./series")
+    return "" unless s
+    f = s.at("./formattedref")
+    return f.text if f
+    t = s.at("./title")
+    a = s.at("./abbreviation")
+    n = s.at("./number")
+    p = s.at("./partnumber")
+    dn = doc.at("./docnumber")
+    rev = doc&.at(".//edition")&.text&.sub(/^Revision /, "")
+    ret = ""
+    if t
+      title = included(type) ? wrap(t.text, " <I>", "</I>") : wrap(t.text, " ", "")
+      ret += title
+      ret += " (#{a.text.sub(/^NIST /, "")})" if a
+    end
+    if n || p
+      ret += " #{n.text}" if n
+      ret += ".#{p.text}" if p
+    elsif dn && is_nist(doc)
+      ret += " #{dn.text}"
+      ret += " Rev. #{rev}" if rev
+    end
+    ret
+  end
+
+  def self.standardidentifier(doc)
+    ret = []
+    doc.xpath("./docidentifier").each do |id|
+      next if %w(nist-mr nist-long metanorma rfc-anchor).include? id["type"]
+      ret << standardidentifier1(id)
+    end
+    ret.join(". ")
+  end
+
+  def self.standardidentifier1(id)
+    r = ""
+    r += "#{id['type']} " if id["type"] and
+      !%w(ISO IEC NIST).include? id["type"]
+    r += id.text
+    r
+  end
+
+  def self.uri(doc)
+    uri = doc.at("./uri[@type = 'doi']") ||
+      doc.at("./uri[@type = 'uri']") ||
+      doc.at("./uri")
+    uri&.text
+  end
+
+  def self.accessLocation(doc)
+    s = doc.at("./accessLocation") or return ""
+    s.text
+  end
+
+  def self.included(type)
+    ["article", "inbook", "incollection", "inproceedings"].include? type
+  end
+
+  def self.wrap(text, startdelim = " ", enddelim = ".")
+    return "" if text.nil? || text.empty?
+    "#{startdelim}#{text}#{enddelim}"
+  end
+
+  def self.type(doc)
+    type = doc.at("./@type") and return type&.text
+    doc.at("./includedIn") and return "inbook"
+    "book"
+  end
+
+  def self.extent2(type, from, to)
+    ret = ""
+    case type 
+    when "page" then type = to ? "pp." : "p."
+    when "volume" then type = to ? "Vols." : "Vol."
+    end
+    ret += "#{type} "
+    ret += from.text if from
+    ret += "&ndash;#{to.text}" if to
+    ret
+  end
+
+  def self.extent1(localities)
+    ret = []
+    localities.each do |l|
+      ret << extent2(l["type"] || "page", 
+                     l.at("./referenceFrom"), l.at("./referenceTo"))
+    end
+    ret.join(", ")
+  end
+
+  def self.extent(localities)
+    ret = []
+    ret1 = ""
+    localities.each do |l|
+      if %w(localityStack).include? l.name
+        ret << ret1
+        ret1 = ""
+        ret << extent1(l.children)
+      else
+        ret1 += extent1([l])
+      end
+    end
+    ret << ret1
+    ret.reject { |c| c.empty? }.join("; ")
+  end
+
+  def self.draft(doc)
+    return nil unless is_nist(doc)
+    dr = doc&.at("./status/stage")&.text
+    iter = doc&.at("./status/iteration")&.text
+    return nil unless /^draft/.match(dr)
+    iterord = iter_ordinal(doc)
+    status = status_print(dr)
+    status = "#{iterord} #{status}" if iterord
+    status
+  end
+
+  def self.iter_ordinal(isoxml)
+    docstatus = isoxml.at(("./status/stage"))&.text
+    return nil unless docstatus == "draft-public"
+    iter = isoxml.at(("./status/iteration"))&.text || "1"
+    return "Initial" if iter == "1"
+    return "Final" if iter.downcase == "final"
+    iter.to_i.localize.to_rbnf_s("SpelloutRules", "spellout-ordinal").capitalize
+  end
+
+  def self.status_print(status)
+    case status
+    when "draft-internal" then "Internal Draft"
+    when "draft-wip" then "Work-in-Progress Draft"
+    when "draft-prelim" then "Preliminary Draft"
+    when "draft-public" then "Public Draft"
+    when "draft-approval" then "Approval Draft"
+    when "final" then "Final"
+    when "final-review" then "Under Review"
+    end
+  end
+
+  def self.parse(doc, embedded = false)
+    ret = ""
+    f = doc.at("./formattedref") and 
+      return embedded ? f.children.to_xml : "<p>#{f.children.to_xml}</p>"
+
+    type = type(doc)
+    container = doc.at("./relation[@type='includedIn']")
+    if container && !date(doc) && date(container&.at("./bibitem"))
+      doc << 
+      ( container&.at("./bibitem/date[@type = 'issued' or @type = 'published' or "\
+                      "@type = 'circulated']")&.remove )
+    end
+    ser = series_title(doc)
+    dr = draft(doc)
+
+    # NIST has seen fit to completely change rendering based on the type of publication.
+    if ser == "NIST Federal Information Processing Standards"
+      ret += "National Institute of Standards and Technology"
+    else
+      ret += embedded ? wrap(creatornames(doc), "", "") : wrap(creatornames(doc), "", "")
+    end
+    if dr
+      mdy = MMMddyyyy(date(doc)) and ret += wrap(mdy, " (", ")")
+    else
+      yr = year(date(doc)) and ret += wrap(yr, " (", ")")
+    end
+    ret += included(type) ? wrap(title(doc)) : wrap(title(doc), " <I>", "</I>.")
+    ret += wrap(medium(doc), " [", "].")
+    #ret += wrap(edition(doc), "", " edition.")
+    s = series(doc, type)
+    ret += wrap(placepub(doc), " (", "),")
+    if dr
+      ret += " Draft (#{dr})"
+    end
+    ret += wrap(series(doc, type), " ", "")
+    ret += "," if !series(doc, type).empty? && date(doc)
+    ret += wrap(date(doc))
+    ret += wrap(standardidentifier(doc)) unless is_nist(doc)
+    ret += wrap(uri(doc))
+    ret += wrap(accessLocation(doc), " At: ", ".")
+    if container 
+      ret += wrap(parse(container.at("./bibitem"), true), " In: ", "")
+      locality = doc.xpath("./extent")
+      ret += wrap(extent(locality))
+    else
+      ret += wrap(extent(doc.xpath("./extent")))
+    end
+    embedded ? ret : "<p>#{ret}</p>"
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-nist-1.2.0/lib/isodoc/nist/render_contributors.rb

@@ -0,0 +1,80 @@
+module Iso690Render
+=begin
+  def self.multiplenames_and(names)
+    return "" if names.length == 0
+    return names[0] if names.length == 1
+    return "#{names[0]} and #{names[1]}" if names.length == 2
+    names[0..-2].join(", ") + " and #{names[-1]}"
+  end
+=end
+
+  def self.multiplenames(names)
+    names.join(", ")
+  end
+
+  def self.extract_orgname(org)
+    name = org.at("./name")
+    name&.text || "--"
+  end
+
+  def self.frontname(given, initials)
+    if given.empty? && initials.empty? then ""
+    elsif initials.empty?
+      given.map{ |m| m.text[0] }.join("")
+    else
+      initials.map{ |m| m.text[0] }.join("")
+    end
+  end
+
+  def self.commajoin(a, b)
+    return a unless b
+    return b unless a
+    #"#{a}, #{b}"
+    "#{a} #{b}"
+  end
+
+  def self.extract_personname(person)
+    completename = person.at("./name/completename")
+    return completename.text if completename
+    surname = person.at("./name/surname")
+    initials = person.xpath("./name/initials")
+    forenames = person.xpath("./name/forename")
+    #given = []
+    #forenames.each { |x| given << x.text }
+    #given.empty? && initials.each { |x| given << x.text }
+    commajoin(surname&.text, frontname(forenames, initials))
+  end
+
+  def self.extractname(contributor)
+    org = contributor.at("./organization")
+    person = contributor.at("./person")
+    return extract_orgname(org) if org
+    return extract_personname(person) if person
+    "--"
+  end
+
+    def self.contributorRole(contributors)
+    return "" unless contributors.length > 0
+    if contributors[0]&.at("role/@type")&.text == "editor"
+      return contributors.length > 1 ? " (Eds.)" : "(Ed.)"
+    end
+    ""
+  end
+
+  def self.creatornames(doc)
+    cr = doc.xpath("./contributor[role/@type = 'author']")
+    cr.empty? and cr = doc.xpath("./contributor[role/@type = 'performer']")
+    cr.empty? and cr = doc.xpath("./contributor[role/@type = 'adapter']")
+    cr.empty? and cr = doc.xpath("./contributor[role/@type = 'translator']")
+    cr.empty? and cr = doc.xpath("./contributor[role/@type = 'editor']")
+    cr.empty? and cr = doc.xpath("./contributor[role/@type = 'publisher']")
+    cr.empty? and cr = doc.xpath("./contributor[role/@type = 'distributor']")
+    cr.empty? and cr = doc.xpath("./contributor")
+    cr.empty? and return ""
+    ret = []
+    cr.each do |x|
+      ret << extractname(x)
+    end
+    multiplenames(ret) + contributorRole(cr)
+  end
+end