metanorma-standoc 1.3.13 → 1.3.14

data/lib/asciidoctor/standoc/cleanup_section.rb

@@ -0,0 +1,195 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "json"
+require "pathname"
+require "open-uri"
+
+module Asciidoctor
+  module Standoc
+    module Cleanup
+       def make_preface(x, s)
+        if x.at("//foreword | //introduction")
+          preface = s.add_previous_sibling("<preface/>").first
+          foreword = x.at("//foreword")
+          preface.add_child foreword.remove if foreword
+          introduction = x.at("//introduction")
+          preface.add_child introduction.remove if introduction
+        end
+        make_abstract(x, s)
+      end
+
+      def make_abstract(x, s)
+        if x.at("//abstract[not(ancestor::bibitem)]")
+          preface = s.at("//preface") || s.add_previous_sibling("<preface/>").first
+          abstract = x.at("//abstract[not(ancestor::bibitem)]").remove
+          preface.prepend_child abstract.remove
+          bibabstract = bibabstract_location(x)
+          dupabstract = abstract.dup
+          dupabstract.traverse { |n| n.remove_attribute("id") }
+          dupabstract.remove_attribute("language")
+          dupabstract.remove_attribute("script")
+          bibabstract.next = dupabstract
+        end
+      end
+
+      def bibabstract_location(x)
+        bibabstract = x.at("//bibdata/script") || x.at("//bibdata/language") ||
+          x.at("//bibdata/contributor[not(following-sibling::contributor)]") ||
+          x.at("//bibdata/date[not(following-sibling::date)]") ||
+          x.at("//docnumber") ||
+          x.at("//bibdata/docidentifier[not(following-sibling::docidentifier)]") ||
+          x.at("//bibdata/uri[not(following-sibling::uri)]") ||
+          x.at("//bibdata/title[not(following-sibling::title)]")
+      end
+
+      def make_bibliography(x, s)
+        if x.at("//sections/references")
+          biblio = s.add_next_sibling("<bibliography/>").first
+          x.xpath("//sections/references").each do |r|
+            biblio.add_child r.remove
+          end
+        end
+      end
+
+      def sections_order_cleanup(x)
+        s = x.at("//sections")
+        make_preface(x, s)
+        make_bibliography(x, s)
+        x.xpath("//sections/annex").reverse_each { |r| s.next = r.remove }
+      end
+
+      def maxlevel(x)
+        max = 5
+        x.xpath("//clause[@level]").each do |c|
+          max = c["level"].to_i if max < c["level"].to_i
+        end
+        max
+      end
+
+      def sections_level_cleanup(x)
+        m = maxlevel(x)
+        return if m < 6
+        m.downto(6).each do |l|
+          x.xpath("//clause[@level = '#{l}']").each do |c|
+            c.delete("level")
+            c.previous_element << c.remove
+          end
+        end
+      end
+
+      def sections_cleanup(x)
+        sections_order_cleanup(x)
+        sections_level_cleanup(x)
+      end
+
+      def obligations_cleanup(x)
+        obligations_cleanup_info(x)
+        obligations_cleanup_norm(x)
+        obligations_cleanup_inherit(x)
+      end
+
+      def obligations_cleanup_info(x)
+        (s = x.at("//foreword")) && s["obligation"] = "informative"
+        (s = x.at("//introduction")) && s["obligation"] = "informative"
+        x.xpath("//references").each { |r| r["obligation"] = "informative" }
+      end
+
+      def obligations_cleanup_norm(x)
+        (s = x.at("//clause[title = 'Scope']")) && s["obligation"] = "normative"
+        (s = x.at("//clause[title = 'Symbols and Abbreviated Terms']")) &&
+          s["obligation"] = "normative"
+        x.xpath("//terms").each { |r| r["obligation"] = "normative" }
+        x.xpath("//symbols-abbrevs").each { |r| r["obligation"] = "normative" }
+      end
+
+      def obligations_cleanup_inherit(x)
+        x.xpath("//annex | //clause").each do |r|
+          r["obligation"] = "normative" unless r["obligation"]
+        end
+        x.xpath(Utils::SUBCLAUSE_XPATH).each do |r|
+          r["obligation"] = r.at("./ancestor::*/@obligation").text
+        end
+      end
+
+      def termdef_stem_cleanup(xmldoc)
+        xmldoc.xpath("//term/p/stem").each do |a|
+          if a.parent.elements.size == 1 # para contains just a stem expression
+            t = Nokogiri::XML::Element.new("admitted", xmldoc)
+            parent = a.parent
+            t.children = a.remove
+            parent.replace(t)
+          end
+        end
+      end
+
+      def termdomain_cleanup(xmldoc)
+        xmldoc.xpath("//p/domain").each do |a|
+          prev = a.parent.previous
+          prev.next = a.remove
+        end
+      end
+
+      def termdomain1_cleanup(xmldoc)
+        xmldoc.xpath("//domain").each do |d|
+          defn = d.at("../definition") and
+            defn.previous = d.remove
+        end
+      end
+
+      def termdefinition_cleanup(xmldoc)
+        xmldoc.xpath("//term").each do |d|
+          first_child = d.at("./p | ./figure | ./formula") || next
+          t = Nokogiri::XML::Element.new("definition", xmldoc)
+          first_child.replace(t)
+          t << first_child.remove
+          d.xpath("./p | ./figure | ./formula").each { |n| t << n.remove }
+        end
+      end
+
+      def termdef_unnest_cleanup(xmldoc)
+        # release termdef tags from surrounding paras
+        nodes = xmldoc.xpath("//p/admitted | //p/deprecates")
+        while !nodes.empty?
+          nodes[0].parent.replace(nodes[0].parent.children)
+          nodes = xmldoc.xpath("//p/admitted | //p/deprecates")
+        end
+      end
+
+      def termdef_boilerplate_cleanup(xmldoc)
+        xmldoc.xpath("//terms/p | //terms/ul").each(&:remove)
+      end
+
+      def termdef_subclause_cleanup(xmldoc)
+        xmldoc.xpath("//terms[terms]").each { |t| t.name = "clause" }
+      end
+
+      def termdocsource_cleanup(xmldoc)
+        f = xmldoc.at("//preface | //sections")
+        xmldoc.xpath("//termdocsource").each do |s|
+          f.previous = s.remove
+        end
+      end
+
+      def term_children_cleanup(xmldoc)
+        xmldoc.xpath("//term").each do |t|
+          t.xpath("./termnote").each { |n| t << n.remove }
+          t.xpath("./termexample").each { |n| t << n.remove }
+          t.xpath("./termsource").each { |n| t << n.remove }
+        end
+      end
+
+      def termdef_cleanup(xmldoc)
+        termdef_unnest_cleanup(xmldoc)
+        termdef_stem_cleanup(xmldoc)
+        termdomain_cleanup(xmldoc)
+        termdefinition_cleanup(xmldoc)
+        termdomain1_cleanup(xmldoc)
+        termdef_boilerplate_cleanup(xmldoc)
+        termdef_subclause_cleanup(xmldoc)
+        term_children_cleanup(xmldoc)
+        termdocsource_cleanup(xmldoc)
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/front.rb

@@ -3,6 +3,7 @@ require "nokogiri"
 require "htmlentities"
 require "pathname"
 require "open-uri"
+require_relative "./front_contributor.rb"
 
 module Asciidoctor
   module Standoc
@@ -24,94 +25,6 @@ module Asciidoctor
         end
       end
 
-      def committee_component(compname, node, out)
-        out.send compname.gsub(/-/, "_"), node.attr(compname),
-          **attr_code(number: node.attr("#{compname}-number"),
-                      type: node.attr("#{compname}-type"))
-        i = 2
-        while node.attr(compname+"_#{i}") do
-          out.send compname.gsub(/-/, "_"), node.attr(compname+"_#{i}"),
-            **attr_code(number: node.attr("#{compname}-number_#{i}"),
-                        type: node.attr("#{compname}-type_#{i}"))
-          i += 1
-        end
-      end
-
-      def organization(org, orgname)
-        org.name orgname
-      end
-
-      def metadata_author(node, xml)
-        (node.attr("publisher") || "").split(/,[ ]?/).each do |p|
-          xml.contributor do |c|
-            c.role **{ type: "author" }
-            c.organization { |a| organization(a, p) }
-          end
-        end
-        personal_author(node, xml)
-      end
-
-      def personal_author(node, xml)
-        (node.attr("fullname") || node.attr("surname")) and
-          personal_author1(node, xml, "")
-        i = 2
-        while node.attr("fullname_#{i}") || node.attr("surname_#{i}")
-          personal_author1(node, xml, "_#{i}")
-          i += 1
-        end
-      end
-
-      def personal_author1(node, xml, suffix)
-        xml.contributor do |c|
-          c.role **{ type: node.attr("role#{suffix}")&.downcase || "author" }
-          c.person do |p|
-            person_name(node, xml, suffix, p)
-            person_affiliation(node, xml, suffix, p)
-            node.attr("phone#{suffix}") and p.phone node.attr("phone#{suffix}")
-            node.attr("fax#{suffix}") and
-              p.phone node.attr("fax#{suffix}"), **{type: "fax"}
-            node.attr("email#{suffix}") and p.email node.attr("email#{suffix}")
-            node.attr("contributor-uri#{suffix}") and
-              p.uri node.attr("contributor-uri#{suffix}")
-          end
-        end
-      end
-
-      def person_name(node, xml, suffix, p)
-        p.name do |n|
-          if node.attr("fullname#{suffix}")
-            n.completename node.attr("fullname#{suffix}")
-          else
-            n.forename node.attr("givenname#{suffix}")
-            n.initial node.attr("initials#{suffix}")
-            n.surname node.attr("surname#{suffix}")
-          end
-        end
-      end
-
-      def person_affiliation(node, xml, suffix, p)
-        node.attr("affiliation#{suffix}") and p.affiliation do |a|
-          a.organization do |o|
-            o.name node.attr("affiliation#{suffix}")
-            abbr = node.attr("affiliation_abbrev#{suffix}") and
-              o.abbreviation abbr
-            node.attr("address#{suffix}") and o.address do |ad|
-              ad.formattedAddress node.attr("address#{suffix}")
-            end
-          end
-        end
-      end
-
-      def metadata_publisher(node, xml)
-        publishers = node.attr("publisher") || return
-        publishers.split(/,[ ]?/).each do |p|
-          xml.contributor do |c|
-            c.role **{ type: "publisher" }
-            c.organization { |a| organization(a, p) }
-          end
-        end
-      end
-
       def metadata_copyright(node, xml)
         publishers = node.attr("publisher") || " "
         publishers.split(/,[ ]?/).each do |p|

data/lib/asciidoctor/standoc/front_contributor.rb

@@ -0,0 +1,99 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "pathname"
+require "open-uri"
+
+module Asciidoctor
+  module Standoc
+    module Front
+      def committee_component(compname, node, out)
+        out.send compname.gsub(/-/, "_"), node.attr(compname),
+          **attr_code(number: node.attr("#{compname}-number"),
+                      type: node.attr("#{compname}-type"))
+        i = 2
+        while node.attr(compname+"_#{i}") do
+          out.send compname.gsub(/-/, "_"), node.attr(compname+"_#{i}"),
+            **attr_code(number: node.attr("#{compname}-number_#{i}"),
+                        type: node.attr("#{compname}-type_#{i}"))
+          i += 1
+        end
+      end
+
+      def organization(org, orgname)
+        org.name orgname
+      end
+
+      def metadata_author(node, xml)
+        (node.attr("publisher") || "").split(/,[ ]?/).each do |p|
+          xml.contributor do |c|
+            c.role **{ type: "author" }
+            c.organization { |a| organization(a, p) }
+          end
+        end
+        personal_author(node, xml)
+      end
+
+      def personal_author(node, xml)
+        (node.attr("fullname") || node.attr("surname")) and
+          personal_author1(node, xml, "")
+        i = 2
+        while node.attr("fullname_#{i}") || node.attr("surname_#{i}")
+          personal_author1(node, xml, "_#{i}")
+          i += 1
+        end
+      end
+
+      def personal_author1(node, xml, suffix)
+        xml.contributor do |c|
+          c.role **{ type: node.attr("role#{suffix}")&.downcase || "author" }
+          c.person do |p|
+            person_name(node, xml, suffix, p)
+            person_affiliation(node, xml, suffix, p)
+            node.attr("phone#{suffix}") and p.phone node.attr("phone#{suffix}")
+            node.attr("fax#{suffix}") and
+              p.phone node.attr("fax#{suffix}"), **{type: "fax"}
+            node.attr("email#{suffix}") and p.email node.attr("email#{suffix}")
+            node.attr("contributor-uri#{suffix}") and
+              p.uri node.attr("contributor-uri#{suffix}")
+          end
+        end
+      end
+
+      def person_name(node, xml, suffix, p)
+        p.name do |n|
+          if node.attr("fullname#{suffix}")
+            n.completename node.attr("fullname#{suffix}")
+          else
+            n.forename node.attr("givenname#{suffix}")
+            n.initial node.attr("initials#{suffix}")
+            n.surname node.attr("surname#{suffix}")
+          end
+        end
+      end
+
+      def person_affiliation(node, xml, suffix, p)
+        node.attr("affiliation#{suffix}") and p.affiliation do |a|
+          a.organization do |o|
+            o.name node.attr("affiliation#{suffix}")
+            abbr = node.attr("affiliation_abbrev#{suffix}") and
+              o.abbreviation abbr
+            node.attr("address#{suffix}") and o.address do |ad|
+              ad.formattedAddress node.attr("address#{suffix}")
+            end
+          end
+        end
+      end
+
+      def metadata_publisher(node, xml)
+        publishers = node.attr("publisher") || return
+        publishers.split(/,[ ]?/).each do |p|
+          xml.contributor do |c|
+            c.role **{ type: "publisher" }
+            c.organization { |a| organization(a, p) }
+          end
+        end
+      end
+    end
+  end
+end