metanorma-ogc 1.1.1 → 1.2.2

data/lib/isodoc/ogc/presentation_xml_convert.rb

@@ -1,9 +1,142 @@
-require_relative "base_convert"
+require_relative "init"
+require_relative "reqt"
 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_label(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_label(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
+
+      def block(docxml)
+        super
+        recommendation_to_table(docxml)
+      end
+
+      include Init
     end
   end
 end

data/lib/isodoc/ogc/reqt.rb

@@ -2,7 +2,7 @@ require "isodoc"
 
 module IsoDoc
   module Ogc
-    module BaseConvert
+    class PresentationXMLConvert < IsoDoc::PresentationXMLConvert
       def recommend_class(node)
         return "recommendtest" if node["type"] == "verification"
         return "recommendtest" if node["type"] == "abstracttest"
@@ -11,62 +11,41 @@ module IsoDoc
         "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|
-          if inject_crossreference_reqt?(node, label)
-            lbl = @xrefs.anchor(@xrefs.reqtlabels[label.text], :xref, false)
-            b << (lbl.nil? ? l10n("#{type}:") : l10n("#{lbl}:"))
-          else
-            b << (lbl.nil? ? l10n("#{type}:") : l10n("#{type} #{lbl}:"))
-          end
-          recommendation_name1(title, node, label, b)
-        end
+        node["type"] == "recommendtest" ?
+          "RecommendationTestTitle" : "RecommendationTitle"
       end
 
-      def recommendation_name1(title, node, label, b)
-        return unless  title && !inject_crossreference_reqt?(node, label)
-        b << " "
-        title.children.each { |n| parse(n,b) }
+      def recommendation_header(r)
+        h = r.add_child("<thead><tr><th scope='colgroup' colspan='2'></th></tr></thead>")
+        recommendation_name(r, h.at(ns(".//th")))
       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
+      def recommendation_name(node, out)
+        b = out.add_child("<p class='#{recommendation_class(node)}'></p>").first
+        if name = node&.at(ns("./name"))&.remove
+          name.children.each { |n| b << n }
+          b << l10n(":")
+        end
+        if title =  node&.at(ns("./title"))&.remove
+          b << l10n(" ") if name
+          title.children.each { |n| b << n }
         end
       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&.text]
+      def recommend_title(node, out)
+        label = node&.at(ns("./label"))&.remove or return
+        b = out.add_child("<tr><td colspan='2'><p></p></td></tr>")
+        p = b.at(ns(".//p"))
+        p << label.children
       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]
+        subj = node&.at(ns("./subject"))&.remove&.children and out << [rec_subj(node), subj]
         node.xpath(ns("./inherit")).each do |i|
-          out << recommendation_attr_parse(i, "Dependency")
+          out << ["Dependency", i.remove.children]
         end
         node.xpath(ns("./classification")).each do |c|
           line = recommendation_attr_keyvalue(c, "tag", "value") and out << line
@@ -75,115 +54,103 @@ module IsoDoc
       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]
+        node["type"] == "recommendclass" ?  "Target Type" : "Subject"
       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]
+        tag = node&.at(ns("./#{key}"))&.remove
+        value = node.at(ns("./#{value}"))&.remove
+        tag && value or return nil
+        node.remove
+        [tag.text.capitalize, value.children]
       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
+          out.add_child("<tr><td>#{i[0]}</td><td>#{i[1]}</td></tr>")
         end
       end
 
-      def reqt_component_attrs(node)
-        attr_code(style: keep_style(node))
+      def preserve_in_nested_table?(node)
+        return true if %w(recommendation requirement permission table).include?(node.name)
+        false
       end
 
       def requirement_component_parse(node, out)
+        node.remove
         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
+        b = out.add_child("<tr><td colspan='2'></td></tr>").first
+        b.at(ns(".//td")) << (preserve_in_nested_table?(node) ? node : node.children)
       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
+          dd = dt&.next_element
+          dt.remove
+          dd&.name == "dd" or next
+          b = out.add_child("<tr><td></td><td></td></tr>")
+          b.at(ns(".//td[1]")) << dt.children
+          b.at(ns(".//td[2]")) << dd.remove.children
         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
+      def recommendation_base(node, klass)
+        node.name = "table"
+        node["class"] = klass
+        node["type"] = recommend_class(node)
       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
+      def recommendation_parse1(node, klass)
+        recommendation_base(node, klass)
+        recommendation_header(node)
+        b = node.add_child("<tbody></tbody>").first
+        recommend_title(node, b)
+        recommendation_attributes(node, b)
+        node.elements.each do |n|
+          next if %w(thead tbody).include?(n.name)
+          requirement_component_parse(n, b)
         end
       end
 
-      def recommendation_parse(node, out)
-        recommendation_parse0(node, out, "recommendation")
-      end
-
-      def recommendation_parse0(node, out, r)
-        label = case node["type"]
-                when "verification" then @labels["#{r}test"]
-                when "class" then @labels["#{r}class"]
-                when "abstracttest" then @labels["abstracttest"]
-                when "conformanceclass" then @labels["conformanceclass"]
-                else 
-                  case r
-                  when "recommendation" then @recommendation_lbl
-                  when "requirement" then @requirement_lbl
-                  when "permission" then @permission_lbl
-                  end
-                end
-        recommendation_parse1(node, out, label)
-      end
-
-      def requirement_parse(node, out)
-        recommendation_parse0(node, out, "requirement")
-      end
-
-      def permission_parse(node, out)
-        recommendation_parse0(node, out, "permission")
+      def recommendation_to_table(docxml)
+        docxml.xpath(ns("//recommendation")).each do |r|
+          recommendation_parse1(r, "recommendation")
+        end
+        docxml.xpath(ns("//requirement")).each do |r|
+          recommendation_parse1(r, "requirement")
+        end
+        docxml.xpath(ns("//permission")).each do |r|
+          recommendation_parse1(r, "permission")
+        end
+        requirement_table_cleanup(docxml)
+      end
+
+      # table nested in table: merge label and caption into a single row
+      def requirement_table_cleanup1(x, y)
+        x.delete("colspan")
+        x.delete("scope")
+        y.delete("colspan")
+        y.delete("scope")
+        x.name = "td"
+        p = x.at(ns("./p[@class = 'RecommendationTitle']")) and
+          p.delete("class")
+        x.parent << y.dup
+        y.parent.remove
+      end
+
+      def requirement_table_cleanup(docxml)
+        docxml.xpath(ns("//table[@type = 'recommendclass']/tbody/tr/td/table")).each do |t|
+          x = t.at(ns("./thead")) and x.replace(x.children)
+          x = t.at(ns("./tbody")) and x.replace(x.children)
+          x = t.at(ns("./tfoot")) and x.replace(x.children)
+          if x = t.at(ns("./tr/th[@colspan = '2']")) and
+              y = t.at(ns("./tr/td[@colspan = '2']"))
+            requirement_table_cleanup1(x, y)
+          end
+          t.parent.parent.replace(t.children)
+        end
       end
     end
   end

data/lib/isodoc/ogc/sections.rb

@@ -1,108 +1,62 @@
 module IsoDoc
   module Ogc
     module BaseConvert
-      def annex_name(annex, name, div)
-        div.h1 **{ class: "Annex" } do |t|
-          t << "#{@xrefs.anchor(annex['id'], :label)} "
-          t.br
-          t.b do |b|
-            name&.children&.each { |c2| parse(c2, b) }
-          end
-        end
-      end
-
-      def keywords(_docxml, out)
-        kw = @meta.get[:keywords]
-        kw.empty? and return
-        @prefacenum += 1
-        out.div **{ class: "Section3" } do |div|
-          clause_name(RomanNumerals.to_roman(@prefacenum).downcase,
-                      "Keywords", div,  class: "IntroTitle")
-          div.p "The following are keywords to be used by search engines and "\
-            "document catalogues."
-          div.p kw.join(", ")
+      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 submittingorgs_path
-        "//bibdata/contributor[role/@type = 'author']/organization/name"
+      def keywords(docxml, out)
+        f = docxml.at(ns("//preface/clause[@type = 'keywords']")) || return
+        intro_clause(f, out)
       end
 
       def submittingorgs(docxml, out)
-        orgs = []
-        docxml.xpath(ns(submittingorgs_path)).each { |org| orgs << org.text }
-        return if orgs.empty?
-        @prefacenum += 1
-        out.div **{ class: "Section3" } do |div|
-          clause_name(RomanNumerals.to_roman(@prefacenum).downcase,
-                      "Submitting Organizations", div,  class: "IntroTitle")
-          div.p "The following organizations submitted this Document to the "\
-            "Open Geospatial Consortium (OGC):"
-          div.ul do |ul|
-            orgs.each { |org| ul.li org }
-          end
-        end
+        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
-        @prefacenum += 1
-        out.div **{ class: "Section3" } do |div|
-          clause_name(@xrefs.anchor(f['id'], :label), "Submitters", div,
-                      class: "IntroTitle")
-          f.elements.each { |e| parse(e, div) unless e.name == "title" }
-        end
+        intro_clause(f, out)
       end
 
       def preface(isoxml, out)
-        title_attr = { class: "IntroTitle" }
-        isoxml.xpath(ns("//preface/clause")).each do |f|
-          @prefacenum += 1
-          out.div **{ class: "Section3", id: f["id"] } do |div|
-            clause_name(RomanNumerals.to_roman(@prefacenum).downcase,
-                        f&.at(ns("./title")), div, title_attr)
-            f.elements.each { |e| parse(e, div) unless e.name == "title" }
-          end
+        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
-        @prefacenum += 1
         page_break(out)
         out.div **attr_code(id: f["id"]) do |s|
-          clause_name(@xrefs.anchor(f["id"], :label), @abstract_lbl, s,
-                      class: "AbstractTitle")
+          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
-        @prefacenum += 1
         page_break(out)
         out.div **attr_code(id: f["id"]) do |s|
-          clause_name(@xrefs.anchor(f["id"], :label), @foreword_lbl, s,
-                      class: "ForewordTitle")
+          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
-        @prefacenum += 1
-        out.div **{ class: "Section3", id: f["id"] } do |div|
-          clause_name(@xrefs.anchor(f["id"], :label), f&.at(ns("./title")), div,
-                      class: "IntroTitle")
-          f.elements.each { |e| parse(e, div) unless e.name == "title" }
-        end
+        intro_clause(f, out)
       end
 
       def conformance(isoxml, out, num)
-        f = isoxml.at(ns("//clause[title = 'Conformance']")) or return num
+        f = isoxml.at(ns("//clause[@type = 'conformance']")) or return num
         out.div **attr_code(id: f["id"]) do |div|
-          num = num + 1
-          clause_name(num, "Conformance", div, nil)
+          clause_name(nil, f&.at(ns("./title")), div, nil)
           f.elements.each { |e| parse(e, div) unless e.name == "title" }
         end
         num