metanorma-cli 1.3.3.1 → 1.3.4

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

@@ -0,0 +1,24 @@
+require_relative "base_convert"
+require "isodoc"
+
+module IsoDoc
+  module Ogc
+    # 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)
+        doctype = docxml&.at(ns("//bibdata/ext/doctype"))&.text
+        doctype = "other" unless %w(abstract-specification-topic best-practice
+        change-request-supporting-document community-practice community-standard 
+        discussion-paper engineering-report policy reference-model release-notes 
+        standard user-guide test-suite white-paper).include? doctype
+        "ogc.#{doctype}.xsl"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,137 @@
+require_relative "init"
+require "isodoc"
+require "uuidtools"
+
+module IsoDoc
+  module Ogc
+    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)
+        insert_submitting_orgs(docxml)
+      end
+
+      def preface_init_insert_pt(docxml)
+        docxml.at(ns("//preface")) ||
+          docxml.at(ns("//sections")).
+          add_previous_sibling("<preface> </preface>").first
+      end
+
+      def submit_orgs_append_pt(docxml)
+        docxml.at(ns("//introduction")) ||
+        docxml.at(ns("//foreword")) ||
+        docxml.at(ns("//preface/clause[@type = 'keywords']")) ||
+        docxml.at(ns("//preface/abstract"))
+      end
+
+      def insert_submitting_orgs(docxml)
+        orgs = []
+        docxml.xpath(ns(submittingorgs_path)).each { |org| orgs << org.text }
+        return if orgs.empty?
+        if a = submit_orgs_append_pt(docxml)
+          a.next = submitting_orgs_clause(orgs)
+        else
+          preface_init_insert_pt(docxml)&.children&.first&.
+            add_previous_sibling(submitting_orgs_clause(orgs))
+        end
+      end
+
+      def submitting_orgs_clause(orgs)
+        <<~END
+        <clause id="_#{UUIDTools::UUID.random_create}" type="submitting_orgs">
+        <title>Submitting Organizations</title>
+        <p>The following organizations submitted this Document to the
+           Open Geospatial Consortium (OGC):</p>
+         <ul>#{orgs.map { |m| "<li>#{m}</li>" }.join("\n")}</ul>
+         </clause>
+        END
+      end
+
+      def keyword_clause(kw)
+        <<~END
+        <clause id="_#{UUIDTools::UUID.random_create}" type="keywords">
+        <title>Keywords</title>
+        <p>The following are keywords to be used by search engines and
+            document catalogues.</p>
+        <p>#{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)
+        else
+          preface_init_insert_pt(docxml)&.children&.first&.
+            add_previous_sibling(keyword_clause(kw))
+        end
+      end
+
+      def example1(f)
+        lbl = @xrefs.anchor(f['id'], :label, false) or return
+        prefix_name(f, "&nbsp;&mdash; ", l10n("#{@i18n.example} #{lbl}"), "name")
+      end
+
+      def recommendation1(f, type)
+        type = recommendation_class(f)
+        label = f&.at(ns("./label"))&.text
+        if inject_crossreference_reqt?(f, label)
+          n = @xrefs.anchor(@xrefs.reqtlabels[label], :xref, false)
+          lbl = (n.nil? ? type : n)
+          f&.at(ns("./title"))&.remove # suppress from display if embedded
+        else
+          n = @xrefs.anchor(f['id'], :label, false)
+          lbl = (n.nil? ? type : l10n("#{type} #{n}"))
+        end
+        prefix_name(f, "", lbl, "name")
+      end
+
+      # embedded reqts xref to top level reqts via label lookup
+      def inject_crossreference_reqt?(node, label)
+        !node.ancestors("requirement, recommendation, permission").empty? &&
+          @xrefs.reqtlabels[label]
+      end
+
+      def recommendation_class(node)
+        case node["type"]
+        when "verification" then @i18n.get["#{node.name}test"]
+        when "class" then @i18n.get["#{node.name}class"]
+        when "abstracttest" then @i18n.get["abstracttest"]
+        when "conformanceclass" then @i18n.get["conformanceclass"]
+        else
+          case node.name
+          when "recommendation" then @i18n.recommendation
+          when "requirement" then @i18n.requirement
+          when "permission" then @i18n.permission
+          end
+        end
+      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, "<br/>", lbl, "title")
+      end
+
+      def clause(docxml)
+        super
+        docxml.xpath(ns("//foreword | //preface/abstract | "\
+                        "//submitters | //introduction | //acknowledgements")).
+                       each do |f|
+          clause1(f)
+        end
+      end
+
+      include Init
+    end
+  end
+end
+

data/gems/ruby/2.6.0/gems/metanorma-ogc-1.2.0/lib/isodoc/ogc/reqt.rb

@@ -0,0 +1,168 @@
+require "isodoc"
+
+module IsoDoc
+  module Ogc
+    module BaseConvert
+      def recommend_class(node)
+        return "recommendtest" if node["type"] == "verification"
+        return "recommendtest" if node["type"] == "abstracttest"
+        return "recommendclass" if node["type"] == "class"
+        return "recommendclass" if node["type"] == "conformanceclass"
+        "recommend"
+      end
+
+      def recommend_table_attr(node)
+        attr_code(id: node["id"], class: recommend_class(node),
+                  style: "border-collapse:collapse;border-spacing:0;"\
+                 "#{keep_style(node)}")
+      end
+
+      REQ_TBL_ATTR =
+        { style: "vertical-align:top;", class: "recommend" }.freeze
+
+      def recommendation_class(node)
+        %w(verification abstracttest).include?(node["type"]) ?
+                  "RecommendationTestTitle" : "RecommendationTitle"
+      end
+
+      def recommendation_name(node, out, type)
+        label, title, lbl = recommendation_labels(node)
+        out.p **{ class: recommendation_class(node) } do |b|
+          lbl and lbl.children.each { |n| parse(n, b) }
+          b << l10n(":")
+          recommendation_name1(title, node, label, b)
+        end
+      end
+
+      def recommendation_name1(title, node, label, b)
+        return unless title
+        b << " "
+        title.children.each { |n| parse(n,b) }
+      end
+
+      def recommend_title(node, out)
+        label = node.at(ns("./label")) or return
+        out.tr do |tr|
+          tr.td **REQ_TBL_ATTR.merge(colspan: 2) do |td|
+            td.p do |p|
+              label.children.each { |n| parse(n, p) }
+            end
+          end
+        end
+      end
+
+      def recommendation_attributes1(node)
+        out = []
+        oblig = node["obligation"] and out << ["Obligation", oblig]
+        subj = node&.at(ns("./subject"))&.text and out << [rec_subj(node), subj]
+        node.xpath(ns("./inherit")).each do |i|
+          out << recommendation_attr_parse(i, "Dependency")
+        end
+        node.xpath(ns("./classification")).each do |c|
+          line = recommendation_attr_keyvalue(c, "tag", "value") and out << line
+        end
+        out
+      end
+
+      def rec_subj(node)
+        %w(class conformanceclass).include?(node["type"]) ?
+          "Target Type" : "Subject"
+      end
+
+      def recommendation_attr_parse(node, label)
+        text = noko do |xml|
+          node.children.each { |n| parse(n, xml) }
+        end.join
+        [label, text]
+      end
+
+      def recommendation_attr_keyvalue(node, key, value)
+        tag = node.at(ns("./#{key}")) or return nil
+        value = node.at(ns("./#{value}")) or return nil
+        [tag.text.capitalize, value.text]
+      end
+
+      def recommendation_attributes(node, out)
+        recommendation_attributes1(node).each do |i|
+          out.tr do |tr|
+            tr.td **REQ_TBL_ATTR do |td|
+              td << i[0]
+            end
+            tr.td **REQ_TBL_ATTR do |td|
+              td << i[1] 
+            end
+          end
+        end
+      end
+
+      def reqt_component_attrs(node)
+        attr_code(style: keep_style(node))
+      end
+
+      def requirement_component_parse(node, out)
+        return if node["exclude"] == "true"
+        node.elements.size == 1 && node.first_element_child.name == "dl" and
+          return reqt_dl(node.first_element_child, out)
+        out.tr do |tr|
+          tr.td **REQ_TBL_ATTR.merge(colspan: 2).
+            merge(reqt_component_attrs(node)) do |td|
+            node.children.each { |n| parse(n, td) }
+          end
+        end
+      end
+
+      def reqt_dl(node, out)
+        node.xpath(ns("./dt")).each do |dt|
+          out.tr do |tr|
+            tr.td **REQ_TBL_ATTR do |td|
+              dt.children.each { |n| parse(n, td) }
+            end
+            dd = dt&.next_element and dd.name == "dd" or next
+            tr.td **REQ_TBL_ATTR do |td|
+              dd.children.each { |n| parse(n, td) }
+            end
+          end
+        end
+      end
+
+      def recommendation_header(node, out, label)
+        out.thead do |h|
+          h.tr do |tr|
+            tr.th **REQ_TBL_ATTR.merge(colspan: 2) do |td|
+              recommendation_name(node, td, label)
+            end
+          end
+        end
+      end
+
+      def recommendation_parse1(node, out, label)
+        out.table **recommend_table_attr(node) do |t|
+          recommendation_header(node, out, label)
+          t.tbody do |b|
+            recommend_title(node, b)
+            recommendation_attributes(node, b)
+            node.children.each do |n|
+              parse(n, t) unless reqt_metadata_node(n)
+            end
+          end
+        end
+      end
+
+      def recommendation_parse(node, out)
+        recommendation_parse0(node, out, "recommendation")
+      end
+
+      def recommendation_parse0(node, out, r)
+        recommendation_parse1(node, out, nil)
+      end
+
+      def requirement_parse(node, out)
+        recommendation_parse0(node, out, "requirement")
+      end
+
+      def permission_parse(node, out)
+        recommendation_parse0(node, out, "permission")
+      end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/metanorma-ogc-1.2.0/lib/isodoc/ogc/sections.rb

@@ -0,0 +1,66 @@
+module IsoDoc
+  module Ogc
+    module BaseConvert
+      def intro_clause(f, out)
+        out.div **{ class: "Section3", id: f["id"] } do |div|
+          clause_name(nil, f&.at(ns("./title")), div, class: "IntroTitle")
+          f.elements.each { |e| parse(e, div) unless e.name == "title" }
+        end
+      end
+
+      def keywords(docxml, out)
+        f = docxml.at(ns("//preface/clause[@type = 'keywords']")) || return
+        intro_clause(f, out)
+      end
+
+      def submittingorgs(docxml, out)
+        f = docxml.at(ns("//preface/clause[@type = 'submitting_orgs']")) || return
+        intro_clause(f, out)
+      end
+
+      def submitters(docxml, out)
+        f = docxml.at(ns("//submitters")) || return
+        intro_clause(f, out)
+      end
+
+      def preface(isoxml, out)
+        isoxml.xpath(ns("//preface/clause[not(@type = 'keywords' or "\
+                        "@type = 'submitting_orgs')]")).each do |f|
+          intro_clause(f, out)
+        end
+      end
+
+      def abstract(isoxml, out)
+        f = isoxml.at(ns("//preface/abstract")) || return
+        page_break(out)
+        out.div **attr_code(id: f["id"]) do |s|
+          clause_name(nil, f&.at(ns("./title")), s, class: "AbstractTitle")
+          f.elements.each { |e| parse(e, s) unless e.name == "title" }
+        end
+      end
+
+      def foreword(isoxml, out)
+        f = isoxml.at(ns("//foreword")) || return
+        page_break(out)
+        out.div **attr_code(id: f["id"]) do |s|
+          clause_name(nil, f&.at(ns("./title")), s, class: "ForewordTitle")
+          f.elements.each { |e| parse(e, s) unless e.name == "title" }
+        end
+      end
+
+      def acknowledgements(isoxml, out)
+        f = isoxml.at(ns("//acknowledgements")) || return
+        intro_clause(f, out)
+      end
+
+      def conformance(isoxml, out, num)
+        f = isoxml.at(ns("//clause[@type = 'conformance']")) or return num
+        out.div **attr_code(id: f["id"]) do |div|
+          clause_name(nil, f&.at(ns("./title")), div, nil)
+          f.elements.each { |e| parse(e, div) unless e.name == "title" }
+        end
+        num
+      end
+    end
+  end
+end

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

@@ -0,0 +1,189 @@
+require_relative "base_convert"
+require_relative "init"
+require "fileutils"
+require "isodoc"
+require_relative "metadata"
+
+module IsoDoc
+  module Ogc
+    # 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__)
+        super
+      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("ogc.scss"),
+          header: html_doc_path("header.html"),
+          wordcoverpage: html_doc_path("word_ogc_titlepage.html"),
+          wordintropage: html_doc_path("word_ogc_intro.html"),
+          ulstyle: "l3",
+          olstyle: "l2",
+        }
+      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 insert_toc(intro, docxml, level)
+        toc = ""
+        toc += make_WordToC(docxml, level)
+        if docxml.at("//p[@class = 'TableTitle']")
+          toc += %{<p class="TOCTitle">List of Tables</p>}
+          toc += make_TableWordToC(docxml)
+        end
+        if docxml.at("//p[@class = 'FigureTitle']")
+          toc += %{<p class="TOCTitle">List of Figures</p>}
+          toc += make_FigureWordToC(docxml)
+        end
+        if docxml.at("//p[@class = 'RecommendationTitle']")
+          toc += %{<p class="TOCTitle">List of Recommendations</p>}
+          toc += make_RecommendationWordToC(docxml)
+        end
+        intro.sub(/WORDTOC/, toc)
+      end
+
+      WORD_TOC_RECOMMENDATION_PREFACE1 = <<~TOC.freeze
+                          <span lang="EN-GB"><span
+        style='mso-element:field-begin'></span><span
+        style='mso-spacerun:yes'>&#xA0;</span>TOC
+        \\h \\z \\t &quot;RecommendationTitle,recommendationtitle&quot; 
+        <span style='mso-element:field-separator'></span></span>
+      TOC
+
+      WORD_TOC_TABLE_PREFACE1 = <<~TOC.freeze
+                          <span lang="EN-GB"><span
+        style='mso-element:field-begin'></span><span
+        style='mso-spacerun:yes'>&#xA0;</span>TOC
+        \\h \\z \\t &quot;TableTitle,tabletitle&quot; <span
+        style='mso-element:field-separator'></span></span>
+      TOC
+
+      WORD_TOC_FIGURE_PREFACE1 = <<~TOC.freeze
+                                      <span lang="EN-GB"><span
+        style='mso-element:field-begin'></span><span
+        style='mso-spacerun:yes'>&#xA0;</span>TOC
+        \\h \\z \\t &quot;FigureTitle,figuretitle&quot; <span
+        style='mso-element:field-separator'></span></span>
+      TOC
+
+      def header_strip(h)
+        h = h.to_s.gsub(/<\/?p[^>]*>/, "")
+        super
+      end
+
+      def make_TableWordToC(docxml)
+        toc = ""
+        docxml.xpath("//p[@class = 'TableTitle']").each do |h|
+          toc += word_toc_entry(1, header_strip(h))
+        end
+        toc.sub(/(<p class="MsoToc1">)/,
+                %{\\1#{WORD_TOC_TABLE_PREFACE1}}) +  WORD_TOC_SUFFIX1
+      end
+
+      def make_FigureWordToC(docxml)
+        toc = ""
+        docxml.xpath("//p[@class = 'FigureTitle']").each do |h|
+          toc += word_toc_entry(1, header_strip(h))
+        end
+        toc.sub(/(<p class="MsoToc1">)/,
+                %{\\1#{WORD_TOC_FIGURE_PREFACE1}}) +  WORD_TOC_SUFFIX1
+      end
+
+      def make_RecommendationWordToC(docxml)
+        toc = ""
+        docxml.xpath("//p[@class = 'RecommendationTitle']").each do |h|
+          toc += word_toc_entry(1, header_strip(h))
+        end
+        toc.sub(/(<p class="MsoToc1">)/,
+                %{\\1#{WORD_TOC_RECOMMENDATION_PREFACE1}}) +  WORD_TOC_SUFFIX1
+      end
+
+      def make_body2(body, docxml)
+        body.div **{ class: "WordSection2" } do |div2|
+          @prefacenum = 0
+          info docxml, div2
+          boilerplate docxml, div2
+          abstract docxml, div2
+          keywords docxml, div2
+          foreword docxml, div2
+          introduction docxml, div2
+          submittingorgs docxml, div2
+          submitters docxml, div2
+          preface docxml, div2
+          acknowledgements docxml, div2
+          div2.p { |p| p << "&nbsp;" } # placeholder
+        end
+        section_break(body)
+      end
+
+      def word_cleanup(docxml)
+        super
+        word_recommend_cleanup(docxml)
+        word_copyright_cleanup(docxml)
+        word_license_cleanup(docxml)
+        word_term_cleanup(docxml)
+        docxml
+      end
+
+      def word_license_cleanup(docxml)
+        x = "//div[@class = 'boilerplate-license']//p[not(@class)]"
+        docxml.xpath(x).each do |p|
+          p["class"] = "license"
+        end
+      end
+
+      # center only the Copyright notice
+      def word_copyright_cleanup(docxml)
+        x = "//div[@class = 'boilerplate-copyright']/div[1]/p[not(@class)]"
+        docxml.xpath(x).each do |p|
+          p["align"] = "center"
+        end
+      end
+
+      def word_term_cleanup(docxml)
+        docxml.xpath("//p[@class = 'TermNum']//p[@class = 'Terms']").each do |p|
+          p.replace(p.children)
+        end
+      end
+
+      def word_recommend_cleanup(docxml)
+        docxml.xpath("//table[@class = 'recommendtest']/thead/tr").each do |tr|
+          style_update(tr, "background:#C9C9C9;")
+        end
+        docxml.xpath("//table[@class = 'recommend']/thead/tr").each do |tr|
+          style_update(tr, "background:#A5A5A5;")
+        end
+        docxml.xpath("//table[@class = 'recommend']/tbody").each do |tr|
+          tr.xpath("./tr").each_slice(2) do |tr1, tr2|
+            tr2 && style_update(tr2, "background:#C9C9C9;")
+          end
+        end
+      end
+
+      include BaseConvert
+      include Init
+    end
+  end
+end