metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/metanorma-itu-1.2.0/lib/isodoc/itu/metadata.rb

@@ -0,0 +1,96 @@
+require "isodoc"
+
+module IsoDoc
+  module ITU
+
+    class Metadata < IsoDoc::Metadata
+      def initialize(lang, script, labels)
+        super
+        here = File.dirname(__FILE__)
+        n = "International_Telecommunication_Union_Logo.svg"
+        set(:logo_html,
+            File.expand_path(File.join(here, "html", n)))
+        set(:logo_comb,
+            File.expand_path(File.join(here, "html", "itu-document-comb.png")))
+        set(:logo_word,
+            File.expand_path(File.join(here, "html", n)))
+      end
+
+      def title(isoxml, _out)
+        main = isoxml&.at(ns("//bibdata/title[@language='#{@lang}']"\
+                             "[@type = 'main']"))&.text
+        set(:doctitle, main)
+        main = isoxml&.at(ns("//bibdata/title[@language='#{@lang}']"\
+                             "[@type = 'subtitle']"))&.text
+        set(:docsubtitle, main)
+        series = isoxml&.at(ns("//bibdata/series[@type='main']/title"))&.text
+        set(:series, series)
+        series1 =
+          isoxml&.at(ns("//bibdata/series[@type='secondary']/title"))&.text
+        set(:series1, series1)
+        series2 =
+          isoxml&.at(ns("//bibdata/series[@type='tertiary']/title"))&.text
+        set(:series2, series2)
+        annext = isoxml&.at(ns("//bibdata/title[@type='annex']"))&.text
+        set(:annextitle, annext)
+      end
+
+      def subtitle(_isoxml, _out)
+        nil
+      end
+
+      def author(isoxml, _out)
+        bureau = isoxml.at(ns("//bibdata/ext/editorialgroup/bureau"))
+        set(:bureau, bureau.text) if bureau
+        tc = isoxml.at(ns("//bibdata/ext/editorialgroup/committee"))
+        set(:tc, tc.text) if tc
+        super
+      end
+
+      def docid(isoxml, _out)
+        dn = isoxml.at(ns("//bibdata/docidentifier[@type = 'ITU']"))
+        set(:docnumber, dn&.text)
+        dn = isoxml.at(ns("//bibdata/ext/structuredidentifier/annexid"))
+        oblig = isoxml&.at(ns("//annex/@obligation"))&.text
+        lbl = oblig == "informative" ? @labels["appendix"] : @labels["annex"]
+        dn and set(:annexid, @i18n.l10n("#{lbl} #{dn&.text}"))
+      end
+
+      def unpublished(status)
+        %w(in-force-prepublished draft).include? status.downcase
+      end
+
+      def bibdate(isoxml, _out)
+        pubdate = isoxml.xpath(ns("//bibdata/date[@type = 'published']"))
+        pubdate and set(:pubdate_monthyear, monthyr(pubdate.text))
+      end
+
+      def monthyr(isodate)
+        m = /(?<yr>\d\d\d\d)-(?<mo>\d\d)/.match isodate
+        return isodate unless m && m[:yr] && m[:mo]
+        return "#{m[:mo]}/#{m[:yr]}"
+      end
+
+      def keywords(isoxml, _out)
+        super
+        set(:keywords, get[:keywords].sort)
+      end
+
+      def doctype(isoxml, _out)
+        d = isoxml&.at(ns("//bibdata/ext/doctype"))&.text
+        set(:doctype_original, d)
+        if d == "recommendation-annex"
+          set(:doctype, "Recommendation")
+        else
+          super
+        end
+      end
+
+      def ip_notice_received(isoxml, _out)
+        received = isoxml.at(ns("//bibdata/ext/ip-notice-received"))&.text ||
+          "false"
+        set(:ip_notice_received, received)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require "isodoc"
+require "fileutils"
+
+module IsoDoc
+  module ITU
+    # 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__)
+        @hierarchical_assets = options[:hierarchical_assets]
+        super
+      end
+
+      def pdf_stylesheet(docxml)
+        case doctype = docxml&.at(ns("//bibdata/ext/doctype"))&.text
+        when "resolution" then "itu.resolution.xsl"
+        when "recommendation-annex" then "itu.recommendation-annex.xsl"
+        else
+          "itu.recommendation.xsl"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,55 @@
+require_relative "init"
+require "isodoc"
+
+module IsoDoc
+  module ITU
+    class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
+      def initialize(options)
+        @hierarchical_assets = options[:hierarchical_assets]
+        super
+      end
+
+      def prefix_container(container, linkend, _target)
+        l10n("#{linkend} #{@i18n.get["in"]} #{@xrefs.anchor(container, :xref)}")
+      end
+
+      def eref(docxml)
+        docxml.xpath(ns("//eref")).each do |f|
+          eref1(f)
+        end
+      end
+
+      def origin(docxml)
+        docxml.xpath(ns("//origin[not(termref)]")).each do |f|
+          eref1(f)
+        end
+      end
+
+      def quotesource(docxml)
+        docxml.xpath(ns("//quote/source")).each do |f|
+          eref1(f)
+        end
+      end
+
+      def eref1(f)
+        get_eref_linkend(f)
+      end
+
+      def get_eref_linkend(node)
+        contents = non_locality_elems(node).select do |c|
+          !c.text? || /\S/.match(c)
+        end
+        return unless contents.empty?
+        link = anchor_linkend(node, docid_l10n(node["target"] || node["citeas"]))
+        link && !/^\[.*\]$/.match(link) and link = "[#{link}]"
+        link += eref_localities(node.xpath(ns("./locality | ./localityStack")),
+                                link)
+        non_locality_elems(node).each { |n| n.remove }
+        node.add_child(link)
+      end
+
+      include Init
+    end
+  end
+end
+

data/gems/ruby/2.6.0/gems/metanorma-itu-1.2.0/lib/isodoc/itu/ref.rb

@@ -0,0 +1,130 @@
+require "isodoc"
+require_relative "metadata"
+require "fileutils"
+
+module IsoDoc
+  module ITU
+    module BaseConvert
+=begin
+      def norm_ref(isoxml, out, num)
+        q = "//bibliography/references[@normative = 'true']"
+        f = isoxml.at(ns(q)) or return num
+        out.div do |div|
+          num = num + 1
+          clause_name(num, f.at(ns("./title")), div, nil)
+          biblio_list(f, div, false)
+        end
+        num
+      end
+=end
+
+      def nonstd_bibitem(list, b, ordinal, biblio)
+        list.tr **attr_code(iso_bibitem_entry_attrs(b, biblio)) do |ref|
+          id = render_identifier(bibitem_ref_code(b))
+          ref.td **{style: "vertical-align:top"} do |td|
+            td << (id[0] || "[#{id[1]}]")&.
+              gsub(/-/, "&#x2011;")&.gsub(/ /, "&#xa0;")
+            date_note_process(b, td)
+          end
+          ref.td { |td| reference_format(b, td) }
+        end
+      end
+
+      def std_bibitem_entry(list, b, ordinal, biblio)
+        nonstd_bibitem(list, b, ordinal, biblio)
+      end
+
+      def biblio_list(f, div, biblio)
+        div.table **{ class: "biblio", border: "0" } do |t|
+          i = 0
+          t.tbody do |tbody|
+            f.elements.each do |b|
+              if b.name == "bibitem"
+                next if implicit_reference(b)
+                i += 1
+                nonstd_bibitem(tbody, b, i, biblio)
+              else
+                unless %w(title clause references).include? b.name
+                  tbody.tx { |tx| parse(b, tx) }
+                end
+              end
+            end
+          end
+        end
+        f.xpath(ns("./clause | ./references")).each do |x|
+          parse(x, div)
+        end
+      end
+
+      def bracket_if_num(x)
+        return nil if x.nil?
+        x = x.text.sub(/^\[/, "").sub(/\]$/, "")
+        "[#{x}]"
+      end
+
+      def reference_format(b, r)
+        reference_format_start(b, r)
+        reference_format_title(b, r)
+      end
+
+      def titlecase(s)
+        s.gsub(/ |\_|\-/, " ").split(/ /).map(&:capitalize).join(" ")
+      end
+
+      def pref_ref_code(b)
+        b.at(ns("./docidentifier[@type = 'ITU']")) || super
+      end
+
+      IGNORE_IDS = "@type = 'DOI' or @type = 'ISSN' or @type = 'ISBN' or "\
+        "@type = 'rfc-anchor'".freeze
+
+      def multi_bibitem_ref_code(b)
+        id = b.xpath(ns("./docidentifier[not(@type = 'metanorma' or "\
+                        "#{IGNORE_IDS})]"))
+        id.empty? and
+          id = b.xpath(ns("./docidentifier[not(@type = 'metanorma')]"))
+        return [] if id.empty?
+        id.sort_by { |i| i["type"] == "ITU" ? 0 : 1 }
+      end
+
+      def render_multi_identifiers(ids)
+        ids.map do |id|
+          id["type"] == "ITU" ? doctype_title(id) : 
+            docid_prefix(id["type"], id.text.sub(/^\[/, "").sub(/\]$/, ""))
+        end.join(" | ")
+      end
+
+      def doctype_title(id)
+        type = id.parent&.at(ns("./ext/doctype"))&.text || "recommendation"
+        if type == "recommendation" &&
+            /^(?<prefix>ITU-[A-Z] [A-Z])[ .-]Sup[a-z]*\.[ ]?(?<num>\d+)$/ =~ id.text
+          "#{prefix}-series Recommendations – Supplement #{num}"
+        else
+          d = docid_prefix(id["type"], id.text.sub(/^\[/, '').sub(/\]$/, ''))
+          "#{titlecase(type)} #{d}"
+        end
+      end
+
+      def reference_format_start(b, r)
+        id = multi_bibitem_ref_code(b)
+        id1 = render_multi_identifiers(id)
+        r << id1
+        date = b.at(ns("./date[@type = 'published']")) and
+          r << " (#{date.text.sub(/-.*$/, '')})"
+        r << ", " if (date || !id1.empty?)
+      end
+
+      def reference_format_title(b, r)
+        if ftitle = b.at(ns("./formattedref"))
+          ftitle&.children&.each { |n| parse(n, r) }
+          /\.$/.match(ftitle&.text) or r << "."
+        elsif title = iso_title(b)
+          r.i do |i|
+            title&.children&.each { |n| parse(n, i) }
+          end
+          /\.$/.match(title&.text) or r << "."
+        end
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-itu-1.2.0/lib/isodoc/itu/terms.rb

@@ -0,0 +1,64 @@
+module IsoDoc
+  module ITU
+    module BaseConvert
+=begin
+      def terms_defs(node, out, num)
+        f = node.at(ns(IsoDoc::Convert::TERM_CLAUSE)) or return num
+        out.div **attr_code(id: f["id"]) do |div|
+          num = num + 1
+          clause_name(num, f.at(ns("./title")), div, nil)
+          if f.at(ns("./clause | ./terms | ./term")).nil? then out.p "None."
+          else
+            f.children.reject { |c1| c1.name == "title" }.each do |c1|
+              parse(c1, div)
+            end
+          end
+        end
+        num
+      end
+
+      def terms_parse(node, out)
+        out.div **attr_code(id: node["id"]) do |div|
+          clause_parse_title(node, div, node.at(ns("./title")), out)
+          if node.at(ns("./clause | ./term")).nil? then out.p "None."
+          else
+            node.children.reject { |c1| c1.name == "title" }.each do |c1|
+              parse(c1, div)
+            end
+          end
+        end
+      end
+=end
+
+      def termdef_parse1(node, div, defn, source)
+        div.p **{ class: "TermNum", id: node["id"] } do |p|
+          p.b do |b|
+            node&.at(ns("./name"))&.children&.each { |n| parse(n, b) }
+            insert_tab(b, 1)
+            node&.at(ns("./preferred"))&.children&.each { |n| parse(n, b) }
+          end
+          source and p << " #{bracket_opt(source.value)}"
+          p << ": "
+        end
+        defn and defn.children.each { |n| parse(n, div) }
+      end
+
+      def termdef_parse(node, out)
+        defn = node.at(ns("./definition"))
+        source = node.at(ns("./termsource/origin/@citeas"))
+        out.div **attr_code(id: node["id"]) do |div|
+          termdef_parse1(node, div, defn, source)
+          set_termdomain("")
+          node.children.each do |n|
+            next if %w(preferred definition termsource title name).include? n.name
+            parse(n, out)
+          end
+        end
+      end
+
+      def termnote_delim
+        " &ndash; "
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-itu-1.2.0/lib/isodoc/itu/word_convert.rb

@@ -0,0 +1,238 @@
+require "isodoc"
+require_relative "init"
+require "fileutils"
+
+module IsoDoc
+  module ITU
+    # A {Converter} implementation that generates Word output, and a document
+    # schema encapsulation of the document for validation
+
+    class WordConvert < IsoDoc::WordConvert
+      def initialize(options)
+        @libdir = File.dirname(__FILE__)
+        @hierarchical_assets = options[:hierarchical_assets]
+        super
+      end
+
+      def make_body(xml, docxml)
+        body_attr = { lang: "EN-US", link: "blue", vlink: "#954F72" }
+        xml.body **body_attr do |body|
+          make_body1(body, docxml)
+          make_body2(body, docxml)
+          make_body3(body, docxml)
+        end
+      end
+
+      def make_body2(body, docxml)
+        body.div **{ class: "WordSection2" } do |div2|
+          info docxml, div2 
+          boilerplate docxml, div2
+          abstract docxml, div2
+          keywords docxml, div2
+          preface docxml, div2
+          div2.p { |p| p << "&nbsp;" } # placeholder
+        end
+        section_break(body)
+      end
+
+      def abstract(isoxml, out)
+        f = isoxml.at(ns("//preface/abstract")) || return
+        out.div **attr_code(id: f["id"], class: "Abstract") do |s|
+          clause_name(nil, "Summary", s, class: "AbstractTitle")
+          f.elements.each { |e| parse(e, s) unless e.name == "title" }
+        end
+      end
+
+      def keywords(_docxml, out)
+        kw = @meta.get[:keywords]
+        kw.nil? || kw.empty? and return
+        out.div **attr_code(class: "Keyword") do |div|
+          clause_name(nil, "Keywords", div,  class: "IntroTitle")
+          div.p kw.join(", ") + "."
+        end
+      end
+
+      def word_preface_cleanup(docxml)
+        docxml.xpath("//h1[@class = 'AbstractTitle'] | "\
+                     "//h1[@class = 'IntroTitle']").each do |h2|
+          h2.name = "p"
+          h2["class"] = "h1Preface"
+        end
+      end
+
+      def word_term_cleanup(docxml)
+        docxml.xpath("//p[@class = 'TermNum']").each do |t|
+        end
+      end
+
+      def word_cleanup(docxml)
+        word_footnote_cleanup(docxml)
+        word_title_cleanup(docxml)
+        word_preface_cleanup(docxml)
+        word_term_cleanup(docxml)
+        word_history_cleanup(docxml)
+        authority_hdr_cleanup(docxml)
+        super
+        docxml
+      end
+
+      def word_footnote_cleanup(docxml)
+        docxml.xpath("//aside").each do |a|
+          a.first_element_child.children.first.previous =
+            '<span style="mso-tab-count:1"/>'
+        end
+      end
+
+      def word_title_cleanup(docxml)
+        docxml.xpath("//p[@class = 'annex_obligation']").each do |h|
+          h&.next_element&.name == "p" or next
+          h.next_element["class"] ||= "Normalaftertitle"
+        end
+        docxml.xpath("//p[@class = 'FigureTitle']").each do |h|
+          h&.parent&.next_element&.name == "p" or next
+          h.parent.next_element["class"] ||= "Normalaftertitle"
+        end
+      end
+
+      def word_history_cleanup(docxml)
+        docxml.xpath("//div[@id='_history']//table").each do |t|
+          t["class"] = "MsoNormalTable"
+          t.xpath(".//td").each { |td| td["style"] = nil }
+        end
+      end
+
+      def word_preface(docxml)
+        super
+        abstractbox = docxml.at("//div[@id='abstractbox']")
+        historybox = docxml.at("//div[@id='historybox']")
+        sourcebox = docxml.at("//div[@id='sourcebox']")
+        keywordsbox = docxml.at("//div[@id='keywordsbox']")
+        abstract = docxml.at("//div[@class = 'Abstract']")
+        history = docxml.at("//div[@class = 'history']")
+        source = docxml.at("//div[@class = 'source']")
+        keywords = docxml.at("//div[@class = 'Keywords']")
+        abstract.parent = abstractbox if abstract && abstractbox
+        history.parent = historybox if history && historybox
+        source.parent = sourcebox if source && sourcebox
+        keywords.parent = keywordsbox if keywords && keywordsbox
+      end
+
+      def formula_parse1(node, out)
+        out.div **attr_code(class: "formula") do |div|
+          div.p **attr_code(class: "formula") do |p|
+            insert_tab(div, 1)
+            parse(node.at(ns("./stem")), div)
+            if lbl = node&.at(ns("./name"))&.text
+              insert_tab(div, 1)
+              div << "(#{lbl})"
+            end
+          end
+        end
+      end
+
+      def default_fonts(options)
+        { bodyfont: (options[:script] == "Hans" ? '"SimSun",serif' :
+                     '"Times New Roman",serif'),
+                     headerfont: (options[:script] == "Hans" ? '"SimHei",sans-serif' :
+                                  '"Times New Roman",serif'),
+                                  monospacefont: '"Courier New",monospace' }
+      end
+
+      def default_file_locations(options)
+        { wordstylesheet: html_doc_path("wordstyle.scss"),
+          standardstylesheet: html_doc_path("itu.scss"),
+          header: html_doc_path("header.html"),
+          wordcoverpage: html_doc_path("word_itu_titlepage.html"),
+          wordintropage: html_doc_path("word_itu_intro.html"),
+          ulstyle: "l3",
+          olstyle: "l2", }
+      end
+
+      def make_tr_attr(td, row, totalrows, header)
+        super.merge(valign: "top")
+      end
+
+      def ol_attrs(node)
+        { class: node["class"], id: node["id"], style: keep_style(node) }
+      end
+
+      def toWord(result, filename, dir, header)
+        result = populate_template(result, :word)
+        result = from_xhtml(word_cleanup(to_xhtml(result)))
+        unless @landscapestyle.nil? || @landscapestyle.empty?
+          @wordstylesheet&.open
+          @wordstylesheet&.write(@landscapestyle)
+          @wordstylesheet&.close
+        end
+        Html2Doc.process(result, filename: filename, 
+                         stylesheet: @wordstylesheet&.path,
+                         header_file: header&.path, dir: dir,
+                         asciimathdelims: [@openmathdelim, @closemathdelim],
+                         liststyles: { ul: @ulstyle, ol: @olstyle, 
+                                       steps: "l4" })
+        header&.unlink
+        @wordstylesheet&.unlink
+      end
+
+      def link_parse(node, out)
+        out.a **attr_code(href: node["target"], title: node["alt"], 
+                          class: "url") do |l|
+          if node.text.empty?
+            l << node["target"].sub(/^mailto:/, "")
+          else
+            node.children.each { |n| parse(n, l) }
+          end
+        end
+      end
+
+      def authority_hdr_cleanup(docxml)
+        docxml&.xpath("//div[@id = 'draft-warning']").each do |d|
+          d.xpath(".//h1 | .//h2").each do |p|
+            p.name = "p"
+            p["class"] = "draftwarningHdr"
+          end
+        end
+        %w(copyright license legal).each do |t|
+          docxml&.xpath("//div[@class = 'boilerplate-#{t}']").each do |d|
+            p = d&.at("./descendant::h1[2]") and
+              p.previous = "<p>&nbsp;</p><p>&nbsp;</p><p>&nbsp;</p>"
+            d.xpath(".//h1 | .//h2").each do |p|
+              p.name = "p"
+              p["class"] = "boilerplateHdr"
+            end
+          end
+        end
+      end
+
+      def authority_cleanup(docxml)
+        dest = docxml.at("//div[@class = 'draft-warning']")
+        auth = docxml.at("//div[@id = 'draft-warning']")
+        dest and auth and dest.replace(auth.remove)
+        %w(copyright license legal).each do |t|
+          dest = docxml.at("//div[@id = 'boilerplate-#{t}-destination']")
+          auth = docxml.at("//div[@class = 'boilerplate-#{t}']")
+          next unless auth && dest
+          t == "copyright" and p = auth&.at(".//p") and
+            p["class"] = "boilerplateHdr"
+          auth&.xpath(".//p[not(@class)]")&.each_with_index do |p, i|
+            p["class"] = "boilerplate"
+            #i == 0 && t == "copyright" and p["style"] = "text-align:center;"
+          end
+          t == "copyright" or
+            auth << "<p>&nbsp;</p><p>&nbsp;</p><p>&nbsp;</p>" 
+          dest.replace(auth.remove)
+        end
+      end
+
+      def clause_attrs(node)
+        ret = {}
+        %w(source history).include?(node["type"]) and
+          ret = { class: node["type"] }
+        super.merge(ret)
+      end
+
+      include BaseConvert
+      include Init
+    end
+  end
+end