metanorma-cli 1.3.3.1 → 1.3.4

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

@@ -0,0 +1,205 @@
+module Asciidoctor
+  module ITU
+    class Converter < Standoc::Converter
+      def sections_cleanup(x)
+        super
+        insert_missing_sections(x) unless @no_insert_missing_sections
+        insert_empty_clauses(x)
+      end
+
+      def table_cleanup(xmldoc)
+        super
+        xmldoc.xpath("//thead/tr[1]/th | //thead/tr[1]/td").each do |t|
+          text = t.at("./descendant::text()") or next
+          text.replace(text.text.titlecase)
+        end
+      end
+
+      def insert_missing_sections(x)
+        insert_scope(x)
+        insert_norm_ref(x)
+        insert_terms(x)
+        insert_symbols(x)
+        insert_conventions(x)
+      end
+
+      def add_id
+        %(id="_#{UUIDTools::UUID.random_create}")
+      end
+
+      def insert_scope(x)
+        x.at("./*/sections") or
+          x.at("./*/preface | ./*/boilerplate | ./*/bibdata").next =
+          "<sections><sentinel/></sections>"
+        x.at("./*/sections/*") or x.at("./*/sections") << "<sentinel/>"
+        ins = x.at("//sections").elements.first
+        unless x.at("//sections/clause[@type = 'scope']")
+          ins.previous =
+            "<clause type='scope' #{add_id}><title>#{@i18n.scope}</title><p>"\
+            "#{@i18n.clause_empty}</p></clause>"
+        end
+        x&.at("//sentinel")&.remove
+      end
+
+      def insert_norm_ref(x)
+        x.at("//bibliography") or
+          x.at("./*/annex[last()] | ./*/sections").next =
+          "<bibliography><sentinel/></bibliography>"
+        ins = x.at("//bibliography").elements.first
+        unless x.at("//bibliography/references[@normative = 'true']")
+          ins.previous = "<references #{add_id} normative='true'>"\
+            "<title>#{@i18n.normref}</title></references>"
+        end
+        x&.at("//sentinel")&.remove
+      end
+
+      def insert_terms(x)
+        ins =  x.at("//sections/clause[@type = 'scope']")
+        unless x.at("//sections//terms")
+          ins.next = "<terms #{add_id}><title>#{@i18n.termsdef}</title></terms>"
+        end
+      end
+
+      def insert_symbols(x)
+        ins =  x.at("//sections/terms") ||
+          x.at("//sections/clause[descendant::terms]")
+        unless x.at("//sections//definitions")
+          ins.next = "<definitions #{add_id}>"\
+            "<title>#{@i18n.symbolsabbrev}</title></definitions>"
+        end
+      end
+
+      def insert_conventions(x)
+        ins =  x.at("//sections//definitions") ||
+          x.at("//sections/clause[descendant::definitions]")
+        unless x.at("//sections/clause[@type = 'conventions']")
+          ins.next = "<clause #{add_id} type='conventions'>"\
+            "<title>#{@i18n.conventions}</title><p>"\
+            "#{@i18n.clause_empty}</p></clause>"
+        end
+      end
+
+      def insert_empty_clauses(x)
+        x.xpath("//terms[not(./term)][not(.//terms)]").each do |c|
+          insert_empty_clauses1(c, @i18n.clause_empty)
+        end
+        x.xpath("//definitions[not(./dl)]").each do |c|
+          insert_empty_clauses1(c, @i18n.clause_empty)
+        end
+      end
+
+      def insert_empty_clauses1(c, text)
+        c.at("./p") and return
+        ins = c.at("./title") or return
+        ins.next = "<p>#{text}</p>"
+      end
+
+      def cleanup(xmldoc)
+        symbols_cleanup(xmldoc)
+        super
+        obligations_cleanup(xmldoc)
+        xmldoc
+      end
+
+      def smartquotes_cleanup(xmldoc)
+        return super if @smartquotes
+        xmldoc.traverse do |n|
+          next unless n.text?
+          n.replace(HTMLEntities.new.encode(
+            n.text.gsub(/\u2019|\u2018|\u201a|\u201b/, "'").
+            gsub(/\u201c|\u201d|\u201e|\u201f/, '"'), :basic))
+        end
+        xmldoc
+      end
+
+      def termdef_boilerplate_cleanup(xmldoc)
+      end
+
+      def terms_extract(div)
+        internal = div.at("./terms[@type = 'internal']/title")
+        external = div.at("./terms[@type = 'external']/title")
+        [internal, external]
+      end
+
+      def term_defs_boilerplate(div, source, term, preface, isodoc)
+        internal, external = terms_extract(div.parent)
+        internal&.next_element&.name == "term" and
+          internal.next = "<p>#{@i18n.internal_terms_boilerplate}</p>"
+        internal and internal&.next_element == nil and
+          internal.next = "<p>#{@i18n.no_terms_boilerplate}</p>"
+        external&.next_element&.name == "term" and
+          external.next = "<p>#{@i18n.external_terms_boilerplate}</p>"
+        external and external&.next_element == nil and
+          external.next = "<p>#{@i18n.no_terms_boilerplate}</p>"
+        !internal and !external and
+          %w(term terms).include? div&.next_element&.name and
+          div.next = "<p>#{@i18n.term_def_boilerplate}</p>"
+      end
+
+      def section_names_terms_cleanup(x)
+        super
+        replace_title(
+          x, "//terms[@type = 'internal'] | "\
+          "//clause[./terms[@type = 'internal']][not(./terms[@type = 'external'])]", 
+          @i18n&.internal_termsdef)
+        replace_title(
+          x, "//terms[@type = 'external'] | "\
+          "//clause[./terms[@type = 'external']][not(./terms[@type = 'internal'])]", 
+          @i18n&.external_termsdef)
+      end
+
+      def symbols_cleanup(xmldoc)
+        sym = xmldoc.at("//definitions/title")
+        sym and sym&.next_element&.name == "dl" and
+          sym.next = "<p>#{@i18n.symbols_boilerplate}</p>"
+      end
+
+      PUBLISHER = "./contributor[role/@type = 'publisher']/organization".freeze
+
+      def pub_class(bib)
+        return 1 if bib.at("#{PUBLISHER}[abbreviation = 'ITU']")
+        return 1 if bib.at("#{PUBLISHER}[name = 'International "\
+                           "Telecommunication Union']")
+        return 2 if bib.at("#{PUBLISHER}[abbreviation = 'ISO']")
+        return 2 if bib.at("#{PUBLISHER}[name = 'International Organization "\
+                           "for Standardization']")
+        return 3 if bib.at("#{PUBLISHER}[abbreviation = 'IEC']")
+        return 3 if bib.at("#{PUBLISHER}[name = 'International "\
+                           "Electrotechnical Commission']")
+        return 4 if bib.at("./docidentifier[@type][not(@type = 'DOI' or "\
+                           "@type = 'metanorma' or @type = 'ISSN' or @type = "\
+                           "'ISBN')]")
+        5
+      end
+
+      def sort_biblio(bib)
+        bib.sort do |a, b|
+          sort_biblio_key(a) <=> sort_biblio_key(b)
+        end
+      end
+
+      # sort by: doc class (ITU, ISO, IEC, other standard (not DOI &c), other
+      # then standard class (docid class other than DOI &c)
+      # then alphanumeric doc id (not DOI &c)
+      # then title
+      def sort_biblio_key(bib)
+        pubclass = pub_class(bib)
+        num = bib&.at("./docnumber")&.text
+        id = bib&.at("./docidentifier[not(@type = 'DOI' or @type = "\
+                     "'metanorma' or @type = 'ISSN' or @type = 'ISBN')]")
+        metaid = bib&.at("./docidentifier[@type = 'metanorma']")&.text
+        abbrid = metaid unless /^\[\d+\]$/.match(metaid)
+        type = id['type'] if id
+        title = bib&.at("./title[@type = 'main']")&.text ||
+          bib&.at("./title")&.text || bib&.at("./formattedref")&.text
+        "#{pubclass} :: #{type} :: #{id&.text || metaid} :: #{title}"
+      end
+
+      def biblio_reorder(xmldoc)
+        xmldoc.xpath("//references").each do |r|
+          biblio_reorder1(r)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,143 @@
+require "asciidoctor"
+require "asciidoctor/standoc/converter"
+require "fileutils"
+require_relative "./front.rb"
+require_relative "./validate.rb"
+require_relative "./cleanup.rb"
+require_relative "./macros.rb"
+
+module Asciidoctor
+  module ITU
+    # A {Converter} implementation that generates RSD output, and a document
+    # schema encapsulation of the document for validation
+    #
+    class Converter < Standoc::Converter
+      XML_ROOT_TAG = "itu-standard".freeze
+      XML_NAMESPACE = "https://www.metanorma.org/ns/itu".freeze
+
+      register_for "itu"
+
+      Asciidoctor::Extensions.register do
+        inline_macro AddMacro
+        inline_macro DelMacro
+      end
+
+      def title_validate(root)
+        nil
+      end
+
+      def init(node)
+        super
+        @smartquotes = node.attr("smartquotes") == "true"
+        @no_insert_missing_sections = doctype(node) != "recommendation" ||
+          node.attr("legacy-do-not-insert-missing-sections")
+      end
+
+      def makexml(node)
+        @draft = node.attributes.has_key?("draft")
+        super
+      end
+
+      def doctype(node)
+        ret = node.attr("doctype") || "recommendation"
+        ret = "recommendation" if ret == "article"
+        ret
+      end
+
+      def olist(node)
+        id = Asciidoctor::Standoc::Utils::anchor_or_uuid(node)
+        noko do |xml|
+          xml.ol **attr_code(id: id, class: node.attr("class")) do |xml_ol|
+            node.items.each { |item| li(xml_ol, item) }
+          end
+        end.join("\n")
+      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 validate(doc)
+        content_validate(doc)
+        schema_validate(formattedstr_strip(doc.dup),
+                        File.join(File.dirname(__FILE__), "itu.rng"))
+      end
+
+      def style(n, t)
+        return
+      end
+
+      def sectiontype_streamline(ret)
+        case ret
+        when "definitions" then "terms and definitions"
+        when "abbreviations and acronyms" then "symbols and abbreviated terms"
+        when "references" then "normative references"
+        when "terms defined elsewhere" then "terms and definitions"
+        when "terms defined in this recommendation" then "terms and definitions"
+        else
+          super
+        end
+      end
+
+      def term_def_subclause_parse(attrs, xml, node)
+        case clausetype = sectiontype1(node)
+        when "terms defined in this recommendation"
+          term_def_parse(attrs.merge(type: "internal"), xml, node, false)
+        when "terms defined elsewhere"
+          term_def_parse(attrs.merge(type: "external"), xml, node, false)
+        else
+          super
+        end
+      end
+
+      def metadata_keywords(node, xml)
+        return unless node.attr("keywords")
+        node.attr("keywords").split(/,[ ]*/).sort.each_with_index do |kw, i|
+          xml.keyword (i == 0 ? kw.capitalize : kw)
+        end
+      end
+
+      def clause_parse(attrs, xml, node)
+        case clausetype = sectiontype1(node)
+        when "conventions" then attrs = attrs.merge(type: "conventions")
+        when "history" 
+          attrs[:preface] and attrs = attrs.merge(type: "history")
+        when "source" 
+          attrs[:preface] and attrs = attrs.merge(type: "source")
+        end
+        super
+      end
+
+      def html_extract_attributes(node)
+        super.merge(hierarchical_assets: node.attr("hierarchical-object-numbering"))
+      end
+
+      def doc_extract_attributes(node)
+        super.merge(hierarchical_assets: node.attr("hierarchical-object-numbering"))
+      end
+
+      def presentation_xml_converter(node)
+        IsoDoc::ITU::PresentationXMLConvert.new(html_extract_attributes(node))
+      end
+
+      def html_converter(node)
+        IsoDoc::ITU::HtmlConvert.new(html_extract_attributes(node))
+      end
+
+      def pdf_converter(node)
+        IsoDoc::ITU::PdfConvert.new(html_extract_attributes(node))
+      end
+
+      def doc_converter(node)
+        IsoDoc::ITU::WordConvert.new(doc_extract_attributes(node))
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-itu-1.2.0/lib/asciidoctor/itu/front.rb

@@ -0,0 +1,216 @@
+require "asciidoctor"
+require "asciidoctor/standoc/converter"
+require "fileutils"
+
+module Asciidoctor
+  module ITU
+    class Converter < Standoc::Converter
+      def metadata_status(node, xml)
+        xml.status do |s|
+          s.stage (node.attributes.has_key?("draft") ? "draft" :
+                   (node.attr("status") || node.attr("docstage") ||
+                    "published" ))
+        end
+      end
+
+      def title_english(node, xml)
+        at = { language: "en", format: "text/plain", type: "main" }
+        a = node.attr("title") || node.attr("title-en")
+        xml.title **attr_code(at) do |t|
+          t << (Asciidoctor::Standoc::Utils::asciidoc_sub(a) || node.title)
+        end
+        if a = node.attr("annextitle") || node.attr("annextitle-en")
+          at[:type] = "annex"
+          xml.title **attr_code(at) do |t|
+            t << Asciidoctor::Standoc::Utils::asciidoc_sub(a)
+          end
+        end
+      end
+
+      def title_otherlangs(node, xml)
+        node.attributes.each do |k, v|
+          next unless /^(annex)?title-(?<lang>.+)$/ =~ k
+          next if lang == "en"
+          type = /^annex/.match(k) ? "annex" : "main"
+          xml.title **attr_code(language: lang, format: "text/plain",
+                                type: type) do |t|
+            t << v
+          end
+        end
+      end
+
+      def title(node, xml)
+        super
+        subtitle_english(node, xml)
+        subtitle_otherlangs(node, xml)
+      end
+
+      def subtitle_english(node, xml)
+        at = { language: "en", format: "text/plain", type: "subtitle" }
+        a = node.attr("subtitle") || node.attr("subtitle-en")
+        xml.title **attr_code(at) do |t|
+          t << Asciidoctor::Standoc::Utils::asciidoc_sub(a)
+        end
+      end
+
+      def subtitle_otherlangs(node, xml)
+        node.attributes.each do |k, v|
+          next unless /^subtitle-(?<lang>.+)$/ =~ k
+          next if lang == "en"
+          xml.title **attr_code(language: lang, format: "text/plain",
+                                type: "subtitle") do |t|
+            t << v
+          end
+        end
+      end
+
+      def metadata_author(node, xml)
+        xml.contributor do |c|
+          c.role **{ type: "author" }
+          c.organization do |a|
+            a.name "International Telecommunication Union"
+            a.abbreviation "ITU"
+          end
+        end
+      end
+
+      def metadata_publisher(node, xml)
+        xml.contributor do |c|
+          c.role **{ type: "publisher" }
+          c.organization do |a|
+            a.name "International Telecommunication Union"
+            a.abbreviation "ITU"
+          end
+        end
+      end
+
+      def metadata_committee(node, xml)
+        metadata_committee1(node, xml, "")
+        suffix = 2
+        while node.attr("bureau_#{suffix}")
+          metadata_committee1(node, xml, "_#{suffix}")
+          suffix += 1
+        end
+      end
+
+      def metadata_committee1(node, xml, suffix)
+        xml.editorialgroup do |a|
+          a.bureau ( node.attr("bureau#{suffix}") || "T" )
+          if node.attr("group#{suffix}")
+            a.group **attr_code(type: node.attr("grouptype#{suffix}")) do |g|
+              metadata_committee2(node, g, suffix, "")
+            end
+          end
+          if node.attr("subgroup#{suffix}")
+            a.subgroup **attr_code(type: node.attr("subgrouptype#{suffix}")) do |g|
+              metadata_committee2(node, g, suffix, "sub")
+            end
+          end
+          if node.attr("workgroup#{suffix}")
+            a.workgroup **attr_code(type: node.attr("workgrouptype#{suffix}")) do |g|
+              metadata_committee2(node, g, suffix, "work")
+            end
+          end
+        end
+      end
+
+      def metadata_committee2(node, g, suffix, prefix)
+        g.name node.attr("#{prefix}group#{suffix}")
+        node.attr("#{prefix}groupacronym#{suffix}") and
+          g.acronym node.attr("#{prefix}groupacronym#{suffix}")
+        if node.attr("#{prefix}groupyearstart#{suffix}")
+          g.period do |p|
+            p.start node.attr("#{prefix}groupyearstart#{suffix}")
+            node.attr("#{prefix}groupacronym#{suffix}") and
+              p.end node.attr("#{prefix}groupyearend#{suffix}")
+          end
+        end
+      end
+
+      def metadata_id(node, xml)
+        provisional_id(node, xml)
+        itu_id(node, xml)
+      end
+
+      def provisional_id(node, xml)
+        return unless node.attr("provisional-name")
+        xml.docidentifier **{type: "ITU-provisional"} do |i|
+          i << node.attr("provisional-name")
+        end
+      end
+
+      def itu_id(node, xml)
+        bureau = node.attr("bureau") || "T"
+        return unless node.attr("docnumber")
+        xml.docidentifier **{type: "ITU"} do |i|
+          i << "ITU-#{bureau} "\
+            "#{node.attr("docnumber")}"
+        end
+        xml.docnumber { |i| i << node.attr("docnumber") }
+      end
+
+      def metadata_copyright(node, xml)
+        from = node.attr("copyright-year") || Date.today.year
+        xml.copyright do |c|
+          c.from from
+          c.owner do |owner|
+            owner.organization do |o|
+              o.name "International Telecommunication Union"
+              o.abbreviation "ITU"
+            end
+          end
+        end
+      end
+
+      def metadata_series(node, xml)
+        node.attr("series") and
+          xml.series **{ type: "main" } do |s|
+          s.title node.attr("series")
+        end
+        node.attr("series1") and
+          xml.series **{ type: "secondary" } do |s|
+          s.title node.attr("series1")
+        end
+        node.attr("series2") and
+          xml.series **{ type: "tertiary" } do |s|
+          s.title node.attr("series2")
+        end
+      end
+
+      def metadata_recommendationstatus(node, xml)
+        return unless node.attr("recommendation-from")
+        xml.recommendationstatus do |s|
+          s.from node.attr("recommendation-from")
+          s.to node.attr("recommendation-to") if node.attr("recommendation-to")
+          if node.attr("approval-process")
+            s.approvalstage **{process: node.attr("approval-process")} do |a|
+              a << node.attr("approval-status")
+            end
+          end
+        end
+      end
+
+      def metadata_ip_notice(node, xml)
+        xml.ip_notice_received (node.attr("ip-notice-received") || "false")
+      end
+
+      def structured_id(node, xml)
+        return unless node.attr("docnumber")
+        xml.structuredidentifier do |i|
+          i.bureau node.attr("bureau") || "T"
+          i.docnumber node.attr("docnumber")
+          a = node.attr("annexid") and i.annexid a
+        end
+      end
+
+      def metadata_ext(node, xml)
+        metadata_doctype(node, xml)
+        metadata_committee(node, xml)
+        metadata_ics(node, xml)
+        metadata_recommendationstatus(node, xml)
+        metadata_ip_notice(node, xml)
+        structured_id(node, xml)
+      end
+    end
+  end
+end