metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/metanorma-gb-1.5.1/lib/asciidoctor/gb/cleanup.rb

@@ -0,0 +1,130 @@
+module Asciidoctor
+  module Gb
+    class Converter < ISO::Converter
+      def termdef_cleanup(xmldoc)
+        super
+        # TODO this should become variant tag
+        localisedstr(xmldoc)
+      end
+
+      ROMAN_TEXT = /\s*[a-z\u00c0-\u00d6\u00d8-\u00f0\u0100-\u0240]/i
+      HAN_TEXT = /\s*[\u4e00-\u9fff]+/
+
+      LOCALISED_ELEMS = "//admitted | //deprecates | //preferred | //prefix | "\
+        "//initial | //addition | //surname | //forename | //name | "\
+        "//abbreviation | //role/description | //affiliation/description | "\
+        "//bibdata/item | //bibitem/title | //bibdata/formattedref | "\
+        "//bibitem/formattedref | //bibdata/note | //bibitem/note | "\
+        "//bibdata/abstract | //bibitem/note ".freeze
+
+      MUST_LOCALISE_ELEMS = %w{admitted deprecates preferred}.freeze
+
+      def localisedstr(xmldoc)
+        xmldoc.xpath(LOCALISED_ELEMS).each do |zh|
+          if zh.at("./string")
+            extract_localisedstrings(zh)
+          elsif MUST_LOCALISE_ELEMS.include? zh.name
+            duplicate_localisedstrings(zh)
+          end
+        end
+      end
+
+      # element consists solely of localised strings, with no attributes
+      def extract_localisedstrings(elem)
+        elem.xpath("./string").each do |s|
+          s.name = elem.name
+        end
+        elem.replace(elem.children)
+      end
+
+      def text_clean(text)
+        text.gsub(/^\s*/, "").gsub(/</, "&lt;").gsub(/>/, "&gt;")
+      end
+
+      def duplicate_localisedstrings(zh)
+        en = zh.dup.remove
+        zh.after(en).after(" ")
+        zh["language"] = "zh"
+        en["language"] = "en"
+        en.traverse do |c|
+          c.text? && c.content = text_clean(c.text.gsub(HAN_TEXT, ""))
+        end
+        zh.traverse do |c|
+          c.text? && c.content = text_clean(c.text.gsub(ROMAN_TEXT, ""))
+        end
+      end
+
+      def termdef_boilerplate_cleanup(xmldoc)
+        return if @keepboilerplate
+        super
+      end
+
+      def cleanup(xmldoc)
+        lang = xmldoc.at("//language")&.text
+        @agencyclass = GbAgencies::Agencies.new(lang, {}, "")
+        super
+        contributor_cleanup(xmldoc)
+        xmldoc
+      end
+
+      def docidentifier_cleanup(xmldoc)
+        id = xmldoc.at("//bibdata/docidentifier[@type = 'gb']") or return
+        scope = xmldoc.at("//gbscope")&.text
+        prefix = xmldoc.at("//gbprefix")&.text
+        mand = xmldoc.at("//gbmandate")&.text || "mandatory"
+        idtext = @agencyclass.docidentifier(scope, prefix, mand, nil, id.text)
+        id.content = idtext&.gsub(/\&#x2002;/, " ")
+        id = xmldoc.at("//bibdata/ext/structuredidentifier/"\
+                       "project-number") or return
+        idtext = @agencyclass.docidentifier(scope, prefix, mand, nil, id.text)
+        id.content = idtext&.gsub(/\&#x2002;/, " ")
+      end
+
+      def committee_cleanup(xmldoc)
+        xmldoc.xpath("//gbcommittee").each do |c|
+          xmldoc.at("//bibdata/contributor").next =
+            "<contributor><role type='technical-committee'/><organization>"\
+            "<name>#{c.text}</name></organization></contributor>"
+        end
+      end
+
+      def agency_value(issuer, scope, prefix, mandate)
+        agency = issuer.content
+        agency == "GB" and
+          agency = @agencyclass.standard_agency1(scope, prefix, mandate)
+        agency = "GB" if agency.nil? || agency.empty?
+        agency
+      end
+
+      def contributor_cleanup(xmldoc)
+        issuer = xmldoc.at("//bibdata/contributor[role/@type = 'issuer']/"\
+                           "organization/name")
+        scope = xmldoc.at("//gbscope")&.text
+        prefix = xmldoc.at("//gbprefix")&.text
+        mandate = xmldoc.at("//gbmandate")&.text || "mandatory"
+        agency = agency_value(issuer, scope, prefix, mandate)
+        owner = xmldoc.at("//copyright/owner/organization/name")
+        owner.content = agency
+        issuer.content = agency
+        committee_cleanup(xmldoc)
+      end
+
+      def omit_docid_prefix(prefix)
+        IsoDoc::Gb::HtmlConvert.new({}).omit_docid_prefix(prefix)
+      end
+
+      def boilerplate_cleanup(xmldoc)
+        isodoc = boilerplate_isodoc(xmldoc)
+        initial_boilerplate(xmldoc, isodoc)
+        return if @keepboilerplate
+        xmldoc.xpath(self.class::TERM_CLAUSE).each do |f|
+          term_defs_boilerplate(f.at("./title"),
+                                xmldoc.xpath(".//termdocsource"),
+                                f.at(".//term"), f.at(".//p"), isodoc)
+        end
+        f = xmldoc.at(self.class::NORM_REF) and
+          norm_ref_preface(f)
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-gb-1.5.1/lib/asciidoctor/gb/converter.rb

@@ -0,0 +1,146 @@
+require "asciidoctor"
+require "asciidoctor/iso/converter"
+require "isodoc/gb/common"
+require "isodoc/gb/word_convert"
+require "isodoc/gb/pdf_convert"
+require "isodoc/gb/presentation_xml_convert"
+require "gb_agencies"
+require_relative "./section_input.rb"
+require_relative "./front.rb"
+require_relative "./validate.rb"
+require_relative "cleanup.rb"
+require "fileutils"
+
+module Asciidoctor
+  module Gb
+    # A {Converter} implementation that generates GB output, and a document
+    # schema encapsulation of the document for validation
+    class Converter < ISO::Converter
+      XML_ROOT_TAG = "gb-standard".freeze
+      XML_NAMESPACE = "https://www.metanorma.org/ns/gb".freeze
+
+      register_for "gb"
+
+      def makexml(node)
+        @draft = node.attributes.has_key?("draft")
+        @keepboilerplate = node.attributes.has_key?("keep-boilerplate")
+        super
+      end
+
+      def gb_attributes(node)
+        {
+          standardlogoimg: node.attr("standard-logo-img"),
+          standardclassimg: node.attr("standard-class-img"),
+          standardissuerimg: node.attr("standard-issuer-img"),
+          titlefont: node.attr("title-font"),
+        }
+      end
+
+      def html_extract_attributes(node)
+        super.merge(gb_attributes(node))
+      end
+
+      def doc_extract_attributes(node)
+        super.merge(gb_attributes(node))
+      end
+
+      def html_converter(node)
+        node.nil? ? IsoDoc::Gb::HtmlConvert.new({}) :
+          IsoDoc::Gb::HtmlConvert.new(html_extract_attributes(node))
+      end
+
+      def html_compliant_converter(node)
+        node.nil? ? IsoDoc::Gb::HtmlConvert.new({}) :
+          IsoDoc::Gb::HtmlConvert.new(html_extract_attributes(node).
+                                      merge(compliant: true))
+      end
+
+      def doc_converter(node)
+        node.nil? ? IsoDoc::Gb::WordConvert.new({}) :
+          IsoDoc::Gb::WordConvert.new(doc_extract_attributes(node))
+      end
+
+      def pdf_converter(node)
+        return nil if node.attr("no-pdf")
+        node.nil? ? IsoDoc::Gb::PdfConvert.new({}) :
+          IsoDoc::Gb::PdfConvert.new(doc_extract_attributes(node))
+      end
+
+      def presentation_xml_converter(node)
+        node.nil? ? IsoDoc::Gb::PresentationXMLConvert.new({}) :
+          IsoDoc::Gb::PresentationXMLConvert.new(html_extract_attributes(node))
+      end
+
+      def outputs(node, ret)
+        File.open(@filename + ".xml", "w:UTF-8") { |f| f.write(ret) }
+        presentation_xml_converter(node).convert(@filename + ".xml")
+        html_compliant_converter(node).
+          convert(@filename + ".presentation.xml", 
+                  nil, false, "#{@filename}_compliant.html")
+        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 inline_quoted(node)
+        ret = noko do |xml|
+          case node.role
+          when "en" then xml.string node.text, **{ language: "en" }
+          when "zh" then xml.string node.text, **{ language: "zh" }
+          when "zh-Hans"
+            xml.string node.text, **{ language: "zh", script: "Hans" }
+          when "zh-Hant"
+            xml.string node.text, **{ language: "zh", script: "Hant" }
+          else
+            nil
+          end
+        end.join
+        return ret unless ret.nil? or ret.empty?
+        super
+      end
+
+      GBCODE = "((AQ|BB|CB|CH|CJ|CY|DA|DB|DL|DZ|EJ|FZ|GA|GH|GM|GY|HB|HG|"\
+        "HJ|HS|HY|JB|JC|JG|JR|JT|JY|LB|LD|LS|LY|MH|MT|MZ|NY|QB|QC|QJ|"\
+        "QZ|SB|SC|SH|SJ|SN|SY|TB|TD|TJ|TY|WB|WH|WJ|WM|WS|WW|XB|YB|YC|"\
+        "YD|YS|YY|YZ|ZY|GB|GBZ|GJB|GBn|GHZB|GWKB|GWPB|JJF|JJG|Q|T)(/Z|/T)?)"
+
+      ISO_REF = %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC|#{GBCODE})[^0-9]*\s[0-9-]+?)
+      ([:-](?<year>(19|20)[0-9][0-9]))?\]</ref>,?\s
+      (?<text>.*)$}xm
+
+      ISO_REF_NO_YEAR = %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC|#{GBCODE})[^0-9]*\s[0-9-]+):--\]</ref>,?\s?
+      <fn[^>]*>\s*<p>(?<fn>[^\]]+)</p>\s*</fn>,?\s?(?<text>.*)$}xm
+
+      ISO_REF_ALL_PARTS = %r{^<ref\sid="(?<anchor>[^"]+)">
+      \[(?<usrlbl>\([^)]+\))?(?<code>(ISO|IEC|#{GBCODE})[^0-9]*\s[0-9]+)\s
+      \(all\sparts\)\]</ref>(<p>)?,?\s?
+      (?<text>.*)(</p>)?$}xm
+
+      def reference1_matches(item)
+        matched = ISO_REF.match item
+        matched2 = ISO_REF_NO_YEAR.match item
+        matched3 = ISO_REF_ALL_PARTS.match item
+        [matched, matched2, matched3]
+      end
+
+      def fetch_ref(xml, code, year, **opts)
+        code = "CN(#{code})" if !/^CN\(/.match(code) &&
+          /^#{GBCODE}[^A-Za-z]/.match(code)
+          super
+      end
+
+      def init(node)
+        node.attr("language") or node.set_attr("language", "zh")
+        node.attr("script") or
+          node.set_attr("script", node.attr("language") == "zh" ?
+                        "Hans" : "Latn")
+        super
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-gb-1.5.1/lib/asciidoctor/gb/front.rb

@@ -0,0 +1,242 @@
+require_relative "front_id"
+
+module Asciidoctor
+  module Gb
+    class Converter < ISO::Converter
+      def doctype(node)
+        type = node.attr("mandate") || "mandatory"
+        type = "standard" if type == "mandatory"
+        type = "recommendation" if type == "recommended"
+        type
+      end
+
+      def metadata_author_personal(node, xml)
+        author = node.attr("author") || return
+        author.split(/, ?/).each do |author|
+          xml.contributor do |c|
+            c.role **{ type: "author" }
+            c.person do |p|
+              p.name do |n|
+                n.surname author
+              end
+            end
+          end
+        end
+      end
+
+      def metadata_contributor1(node, xml, type, role)
+        contrib = node.attr(type) || "GB"
+        contrib.split(/, ?/).each do |c|
+          xml.contributor do |x|
+            x.role **{ type: role }
+            x.organization do |a|
+              a.name { |n| n << c }
+            end
+          end
+        end
+      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 "GB"
+            end
+          end
+        end
+      end
+
+      def metadata_committee(node, xml)
+        return unless node.attr("technical-committee")
+        attrs = { type: node.attr("technical-committee-type") }
+        xml.gbcommittee **attr_code(attrs) do |a|
+          a << node.attr("technical-committee")
+        end
+        i = 2
+        while node.attr("technical-committee_#{i}") do
+          attrs = { type: node.attr("technical-committee-type_#{i}") }
+          xml.gbcommittee **attr_code(attrs) do |a|
+            a << node.attr("technical-committee_#{i}")
+          end
+          i += 1
+        end
+      end
+
+      def metadata_equivalence(node, xml)
+        isostd = node.attr("iso-standard") || return
+        type = node.attr("equivalence") || "equivalent"
+        m = /^(?<code>[^,]+),?(?<title>.*)$/.match isostd
+        title = m[:title].empty? ? "[not supplied]" : m[:title]
+        xml.relation **{ type: "adoptedFrom" } do |r|
+          r.description type
+          r.bibitem do |b|
+            b.title { |t| t << title }
+            b.docidentifier m[:code]
+          end
+        end
+      end
+
+      def metadata_relations(node, xml)
+        metadata_equivalence(node, xml)
+        metadata_obsoletes(node, xml)
+      end
+
+      def metadata_obsoletes(node, xml)
+        std = node.attr("obsoletes") || return
+        m = /^(?<code>[^,]+),?(?<title>.*)$/.match std
+        title = m[:title].empty? ? "[not supplied]" : m[:title]
+        xml.relation **{ type: "obsoletes" } do |r|
+          r.bibitem do |b|
+            b.title { |t| t << title }
+            b.docidentifier m[:code]
+          end
+          r.bpart node.attr("obsoletes-parts") if node.attr("obsoletes-parts")
+        end
+      end
+
+      def get_scope(node)
+        node.attr("scope") and return node.attr("scope")
+        scope = if %r{^[TQ]/}.match node.attr("prefix")
+                  m = node.attr("prefix").split(%{/})
+                  mandate = m[0] == "T" ? "social-group" :
+                    m[0] == "Q" ? "enterprise" : nil
+                end
+        return scope unless scope.nil?
+        @log.add("Document Attributes", nil, "GB: no scope supplied, defaulting to National")
+        "national"
+      end
+
+      def get_prefix(node)
+        scope = get_scope(node)
+        if prefix = node.attr("prefix")
+          prefix.gsub!(%r{/[TZ]$}, "")
+          prefix.gsub!(%r{^[TQ]/([TZ]/)?}, "")
+          prefix.gsub!(/^DB/, "") if scope == "local"
+        else
+          prefix = "GB"
+          scope = "national"
+          @log.add("Document Attributes", nil, "GB: no prefix supplied, defaulting to GB")
+        end
+        [scope, prefix]
+      end
+
+      def get_mandate(node)
+        node.attr("mandate") and return node.attr("mandate")
+        p = node.attr("prefix")
+        mandate = %r{/T}.match(p) ? "recommended" :
+          %r{/Z}.match(p) ? "guidelines" : nil
+        if mandate.nil?
+          mandate = "mandatory"
+          @log.add("Document Attributes", nil, "GB: no mandate supplied, defaulting to mandatory")
+        end
+        mandate
+      end
+
+      def get_topic(node)
+        node.attr("topic") and return node.attr("topic")
+        @log.add("Document Attributes", nil, "GB: no topic supplied, defaulting to basic")
+        "basic"
+      end
+
+      def metadata_gbtype(node, xml)
+        xml.gbtype do |t|
+          scope, prefix = get_prefix(node)
+          t.gbscope { |s| s << scope }
+          t.gbprefix { |p| p << prefix }
+          t.gbmandate { |m| m << get_mandate(node) }
+          t.gbtopic { |t| t << get_topic(node) }
+        end
+      end
+
+      def metadata_gblibraryids(node, xml)
+        ccs = node.attr("library-ccs")
+        ccs and ccs.split(/, ?/).each do |l|
+          xml.ccs { |c| c << l }
+        end
+        l = node.attr("library-plan")
+        l && xml.plannumber { |plan| plan << l }
+      end
+
+      def metadata_author(node, xml)
+        metadata_author_personal(node, xml)
+        metadata_contributor1(node, xml, "author-committee", "author")
+        i = 2
+        while node.attr("author-committee_#{i}") do
+          metadata_contributor1(node, xml, "author-committee_#{i}", "author")
+          i += 1
+        end
+      end
+
+      def metadata_publisher(node, xml)
+        metadata_contributor1(node, xml, "publisher", "publisher")
+        metadata_contributor1(node, xml, "authority", "authority")
+        metadata_contributor1(node, xml, "proposer", "proposer")
+        metadata_contributor1(node, xml, "issuer", "issuer")
+      end
+
+      def metadata_language(node, xml)
+        xml.language (node.attr("language") || "zh")
+      end
+
+      def metadata_script(node, xml)
+        xml.script (node.attr("script") || "Hans")
+      end
+
+      def metadata_ext(node, xml)
+        metadata_doctype(node, xml)
+        metadata_committee(node, xml)
+        metadata_ics(node, xml)
+        structured_id(node, xml)
+        xml.stagename stage_name(get_stage(node), get_substage(node))
+        metadata_gbtype(node, xml)
+        metadata_gblibraryids(node, xml)
+      end
+
+      def title_full(node, lang, t, at)
+        title = node.attr("title-main-#{lang}")
+        intro = node.attr("title-intro-#{lang}")
+        part = node.attr("title-part-#{lang}")
+        title = "#{intro} -- #{title}" if intro
+        title = "#{title} -- #{part}" if part
+        t.title **attr_code(at.merge(type: "main")) do |t1|
+          t1 << Asciidoctor::Standoc::Utils::asciidoc_sub(title)
+        end
+      end
+
+      def title_intro(node, lang, t, at)
+        node.attr("title-intro-#{lang}") and
+          t.title **attr_code(at.merge(type: "title-intro")) do |t1|
+          t1 << Asciidoctor::Standoc::Utils::asciidoc_sub(
+            node.attr("title-intro-#{lang}"))
+        end
+      end
+
+      def title_main(node, lang, t, at)
+        t.title **attr_code(at.merge(type: "title-main")) do |t1|
+          t1 << Asciidoctor::Standoc::Utils::asciidoc_sub(
+            node.attr("title-main-#{lang}"))
+        end
+      end
+
+      def title_part(node, lang, t, at)
+        node.attr("title-part-#{lang}") and
+          t.title **attr_code(at.merge(type: "title-part")) do |t1|
+          t1 << Asciidoctor::Standoc::Utils::asciidoc_sub(
+            node.attr("title-part-#{lang}"))
+        end
+      end
+
+      def title(node, xml)
+        ["en", "zh"].each do |lang|
+          at = { language: lang, format: "plain" }
+          title_full(node, lang, xml, at)
+          title_intro(node, lang, xml, at)
+          title_main(node, lang, xml, at)
+          title_part(node, lang, xml, at)
+        end
+      end
+    end
+  end
+end