metanorma-standoc 0.0.1

data/lib/asciidoctor/standoc/blocks.rb

@@ -0,0 +1,190 @@
+require "htmlentities"
+require "uri"
+
+module Asciidoctor
+  module Standoc
+    module Blocks
+      def id_attr(node = nil)
+        { id: Utils::anchor_or_uuid(node) }
+      end
+
+      # open block is a container of multiple blocks,
+      # treated as a single block.
+      # We append each contained block to its parent
+      def open(node)
+        result = []
+        node.blocks.each do |b|
+          result << send(b.context, b)
+        end
+        result
+      end
+
+      def literal(node)
+        paragraph(node)
+      end
+
+      # NOTE: html escaping is performed by Nokogiri
+      def stem(node)
+        stem_content = node.lines.join("\n")
+        noko do |xml|
+          xml.formula **id_attr(node) do |s|
+            stem_parse(stem_content, s)
+          end
+        end
+      end
+
+      def sidebar_attrs(node)
+        date = node.attr("date") || Date.today.iso8601.gsub(/\+.*$/, "")
+        date += "T00:00:00Z" unless /T/.match date
+        {
+          reviewer: node.attr("reviewer") || node.attr("source") || "(Unknown)",
+          id: Utils::anchor_or_uuid(node),
+          date: date,
+          from: node.attr("from"),
+          to: node.attr("to") || node.attr("from"),
+        }
+      end
+
+      def sidebar(node)
+        return unless draft?
+        noko do |xml|
+          xml.review **attr_code(sidebar_attrs(node)) do |r|
+            wrap_in_para(node, r)
+          end
+        end
+      end
+
+      def termnote(n)
+        noko do |xml|
+          xml.termnote **id_attr(n) do |ex|
+            wrap_in_para(n, ex)
+          end
+        end.join("\n")
+      end
+
+      def note(n)
+        noko do |xml|
+          xml.note **id_attr(n) do |c|
+            wrap_in_para(n, c)
+          end
+        end.join("\n")
+      end
+
+      def admonition_attrs(node)
+        name = node.attr("name")
+        if type = node.attr("type")
+          ["danger", "safety precautions"].each do |t|
+            name = t if type.casecmp(t).zero?
+          end
+        end
+        { id: Utils::anchor_or_uuid(node), type: name }
+      end
+
+      def admonition(node)
+        return termnote(node) if in_terms?
+        return note(node) if node.attr("name") == "note"
+        noko do |xml|
+          xml.admonition **admonition_attrs(node) do |a|
+            wrap_in_para(node, a)
+          end
+        end.join("\n")
+      end
+
+      def term_example(node)
+        noko do |xml|
+          xml.termexample **id_attr(node) do |ex|
+            wrap_in_para(node, ex)
+          end
+        end.join("\n")
+      end
+
+      def example(node)
+        return term_example(node) if in_terms?
+        noko do |xml|
+          xml.example **id_attr(node) do |ex|
+            content = node.content
+            ex << content
+          end
+        end.join("\n")
+      end
+
+      def preamble(node)
+        noko do |xml|
+          xml.foreword do |xml_abstract|
+            xml_abstract.title { |t| t << "Foreword" }
+            content = node.content
+            xml_abstract << content
+          end
+        end.join("\n")
+      end
+
+      def image_attributes(node)
+        uri = node.image_uri node.attr("target")
+        types = MIME::Types.type_for(uri)
+        { src: uri,
+          id: Utils::anchor_or_uuid,
+          imagetype: types.first.sub_type.upcase,
+          height: node.attr("height") || "auto",
+          width: node.attr("width") || "auto" }
+      end
+
+      def figure_title(node, f)
+        unless node.title.nil?
+          f.name { |name| name << node.title }
+        end
+      end
+
+      def image(node)
+        noko do |xml|
+          xml.figure **id_attr(node) do |f|
+            figure_title(node, f)
+            f.image **attr_code(image_attributes(node))
+          end
+        end
+      end
+
+      def paragraph(node)
+        return termsource(node) if node.role == "source"
+        attrs = { align: node.attr("align"),
+                  id: Utils::anchor_or_uuid(node) }
+        noko do |xml|
+          xml.p **attr_code(attrs) do |xml_t|
+            xml_t << node.content
+          end
+        end.join("\n")
+      end
+
+      def quote_attrs(node)
+        { id: Utils::anchor_or_uuid(node), align: node.attr("align") }
+      end
+
+      def quote_attribution(node, out)
+        if node.attr("citetitle")
+          m = /^(?<cite>[^,]+)(,(?<text>.*$))?$/m.match node.attr("citetitle")
+          out.source m[:text],
+            **attr_code(target: m[:cite], type: "inline")
+        end
+        if node.attr("attribution")
+          out.author { |a| a << node.attr("attribution") }
+        end
+      end
+
+      def quote(node)
+        noko do |xml|
+          xml.quote **attr_code(quote_attrs(node)) do |q|
+            quote_attribution(node, q)
+            wrap_in_para(node, q)
+          end
+        end
+      end
+
+      def listing(node)
+        # NOTE: html escaping is performed by Nokogiri
+        noko do |xml|
+          xml.sourcecode(**id_attr(node)) { |s| s << node.content }
+          # xml.sourcecode(**id_attr(node)) { |s| s << node.lines.join("\n") }
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/cleanup.rb

@@ -0,0 +1,247 @@
+require "date"
+require "nokogiri"
+require "pathname"
+require "open-uri"
+require "pp"
+require_relative "./cleanup_block.rb"
+require_relative "./cleanup_footnotes.rb"
+require_relative "./cleanup_ref.rb"
+
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def textcleanup(text)
+        text.gsub(/\s+<fn /, "<fn ")
+      end
+
+      def cleanup(xmldoc)
+        termdef_cleanup(xmldoc)
+        sections_cleanup(xmldoc)
+        obligations_cleanup(xmldoc)
+        table_cleanup(xmldoc)
+        formula_cleanup(xmldoc)
+        figure_cleanup(xmldoc)
+        ref_cleanup(xmldoc)
+        note_cleanup(xmldoc)
+        normref_cleanup(xmldoc)
+        biblio_cleanup(xmldoc)
+        reference_names(xmldoc)
+        xref_cleanup(xmldoc)
+        bpart_cleanup(xmldoc)
+        quotesource_cleanup(xmldoc)
+        para_cleanup(xmldoc)
+        callout_cleanup(xmldoc)
+        origin_cleanup(xmldoc)
+        element_name_cleanup(xmldoc)
+        footnote_renumber(xmldoc)
+        empty_element_cleanup(xmldoc)
+        mathml_cleanup(xmldoc)
+        script_cleanup(xmldoc)
+        docidentifier_cleanup(xmldoc)
+        bookmark_cleanup(xmldoc)
+        xmldoc
+      end
+
+      # ISO as a prefix goes first
+      def docidentifier_cleanup(xmldoc)
+        id = xmldoc.at("//bibdata/docidentifier/project-number")
+        return unless id
+
+        prefix = []
+        xmldoc.xpath("//bibdata/contributor[role/@type = 'publisher']"\
+                     "/organization").each do |x|
+          x1 = x.at("abbreviation")&.text || x.at("name")&.text
+          x1 == "ISO" and prefix.unshift("ISO") or prefix << x1
+        end
+
+        id.content = prefix.join("/") + " " + id.text
+      end
+
+      TEXT_ELEMS =
+        %w{status language script version author name callout phone
+           email street city state country postcode identifier referenceFrom
+           referenceTo docidentifier prefix initial addition surname forename
+           title draft secretariat title-main title-intro title-part}.freeze
+
+      # it seems Nokogiri::XML is treating the content of <script> as cdata,
+      # because of its use in HTML. Bad nokogiri. Undoing that, since we use
+      # script as a normal tag
+      def script_cleanup(xmldoc)
+        xmldoc.xpath("//script").each do |x|
+          x.content = x.to_str
+        end
+      end
+
+      def empty_element_cleanup(xmldoc)
+        xmldoc.xpath("//" + TEXT_ELEMS.join(" | //")).each do |x|
+          x.remove if x.children.empty?
+        end
+      end
+
+      def element_name_cleanup(xmldoc)
+        xmldoc.traverse { |n| n.name = n.name.gsub(/_/, "-") }
+      end
+
+      def link_callouts_to_annotations(callouts, annotations)
+        callouts.each_with_index do |c, i|
+          c["target"] = "_" + UUIDTools::UUID.random_create
+          annotations[i]["id"] = c["target"]
+        end
+      end
+
+      def align_callouts_to_annotations(xmldoc)
+        xmldoc.xpath("//sourcecode").each do |x|
+          callouts = x.elements.select { |e| e.name == "callout" }
+          annotations = x.elements.select { |e| e.name == "annotation" }
+          if callouts.size == annotations.size
+            link_callouts_to_annotations(callouts, annotations)
+          end
+        end
+      end
+
+      def merge_annotations_into_sourcecode(xmldoc)
+        xmldoc.xpath("//sourcecode").each do |x|
+          while x&.next_element&.name == "annotation"
+            x.next_element.parent = x
+          end
+        end
+      end
+
+      def callout_cleanup(xmldoc)
+        merge_annotations_into_sourcecode(xmldoc)
+        align_callouts_to_annotations(xmldoc)
+      end
+
+      def termdef_stem_cleanup(xmldoc)
+        xmldoc.xpath("//term/p/stem").each do |a|
+          if a.parent.elements.size == 1
+            # para containing 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 termdefinition_cleanup(xmldoc)
+        xmldoc.xpath("//term").each do |d|
+          first_child = d.at("./p | ./figure | ./formula") || return
+          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 do |t|
+          t.name = "clause"
+        end
+      end
+
+      def termdocsource_cleanup(xmldoc)
+        f = xmldoc.at("//preface | //sections")
+        xmldoc.xpath("//terms/termdocsource | "\
+                     "//clause/termdocsource").each do |s|
+          f.previous = s.remove
+        end
+      end
+
+      def termdef_cleanup(xmldoc)
+        termdef_unnest_cleanup(xmldoc)
+        termdef_stem_cleanup(xmldoc)
+        termdomain_cleanup(xmldoc)
+        termdefinition_cleanup(xmldoc)
+        termdef_boilerplate_cleanup(xmldoc)
+        termdef_subclause_cleanup(xmldoc)
+        termdocsource_cleanup(xmldoc)
+      end
+
+      def biblio_cleanup(xmldoc)
+        xmldoc.xpath("//references[references]").each do |t|
+          t.name = "clause"
+        end
+      end
+
+      ELEMS_ALLOW_NOTES =
+        # %w[p formula quote sourcecode example admonition ul ol dl figure]
+        %w[p formula ul ol dl figure].freeze
+
+      # if a note is at the end of a section, it is left alone
+      # if a note is followed by a non-note block,
+      # it is moved inside its preceding block if it is not delimited
+      # (so there was no way of making that block include the note)
+      def note_cleanup(xmldoc)
+        q = "//note[following-sibling::*[not(local-name() = 'note')]]"
+        xmldoc.xpath(q).each do |n|
+          next unless n.ancestors("table").empty?
+          prev = n.previous_element || next
+          n.parent = prev if ELEMS_ALLOW_NOTES.include? prev.name
+        end
+      end
+
+      def empty_text_before_first_element(x)
+        x.children.each do |c|
+          if c.text?
+            return false if /\S/.match(c.text)
+          end
+          return true if c.element?
+        end
+        true
+      end
+
+      def strip_initial_space(x)
+        if x.children[0].text?
+          if !/\S/.match(x.children[0].text)
+            x.children[0].remove
+          else
+            x.children[0].content = x.children[0].text.gsub(/^ /, "")
+          end
+        end
+      end
+
+      def bookmark_cleanup(xmldoc)
+        xmldoc.xpath("//li[descendant::bookmark]").each do |x|
+          if x&.elements&.first&.name == "p" &&
+              x&.elements&.first&.elements&.first&.name == "bookmark"
+            if empty_text_before_first_element(x.elements[0])
+              x["id"] = x.elements[0].elements[0].remove["id"]
+              strip_initial_space(x.elements[0])
+            end
+          end
+        end
+      end
+
+      def mathml_cleanup(xmldoc)
+        xmldoc.xpath("//stem[@type = 'MathML']").each do |x|
+          math = x.text.gsub(/&lt;/, "<").gsub(/&gt;/, ">").gsub(/&quot;/, '"').
+            gsub(/&amp;/, "&").gsub(/<[^:\/]+:/, "<").gsub(/<\/[^:]+:/, "</").
+            gsub(/ xmlns[^>]+/, "").
+            gsub(/<math>/, '<math xmlns="http://www.w3.org/1998/Math/MathML">')
+          x.children = math
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/cleanup_block.rb

@@ -0,0 +1,193 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "json"
+require "pathname"
+require "open-uri"
+require "pp"
+
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      def para_cleanup(xmldoc)
+        xmldoc.xpath("//p[not(@id)]").each do |x|
+          x["id"] = Utils::anchor_or_uuid
+        end
+        xmldoc.xpath("//note[not(@id)][not(ancestor::bibitem)]"\
+                     "[not(ancestor::table)]").each do |x|
+          x["id"] = Utils::anchor_or_uuid
+        end
+      end
+
+      # move Key dl after table footer
+      def dl_table_cleanup(xmldoc)
+        q = "//table/following-sibling::*[1]"\
+          "[self::p and normalize-space() = 'Key']"
+        xmldoc.xpath(q).each do |s|
+          if !s.next_element.nil? && s.next_element.name == "dl"
+            s.previous_element << s.next_element.remove
+            s.remove
+          end
+        end
+      end
+
+      def insert_thead(s)
+        thead = s.at("./thead")
+        return thead unless thead.nil?
+        if tname = s.at("./name")
+          thead = tname.add_next_sibling("<thead/>").first
+          return thead
+        end
+        s.children.first.add_previous_sibling("<thead/>").first
+      end
+
+      def header_rows_cleanup(xmldoc)
+        xmldoc.xpath("//table[@headerrows]").each do |s|
+          thead = insert_thead(s)
+          (thead.xpath("./tr").size...s["headerrows"].to_i).each do
+            row = s.at("./tbody/tr")
+            row.parent = thead
+          end
+          s.delete("headerrows")
+        end
+      end
+
+      def table_cleanup(xmldoc)
+        dl_table_cleanup(xmldoc)
+        notes_table_cleanup(xmldoc)
+        header_rows_cleanup(xmldoc)
+      end
+
+      # move notes into table
+      def notes_table_cleanup(xmldoc)
+        nomatches = false
+        until nomatches
+          q = "//table/following-sibling::*[1][self::note]"
+          nomatches = true
+          xmldoc.xpath(q).each do |n|
+            n.previous_element << n.remove
+            nomatches = false
+          end
+        end
+      end
+
+      # include where definition list inside stem block
+      def formula_cleanup(x)
+        q = "//formula/following-sibling::*[1]"\
+          "[self::p and text() = 'where']"
+        x.xpath(q).each do |s|
+          if !s.next_element.nil? && s.next_element.name == "dl"
+            s.previous_element << s.next_element.remove
+            s.remove
+          end
+        end
+      end
+
+      # include key definition list inside figure
+      def figure_dl_cleanup(xmldoc)
+        q = "//figure/following-sibling::*"\
+          "[self::p and normalize-space() = 'Key']"
+        xmldoc.xpath(q).each do |s|
+          if !s.next_element.nil? && s.next_element.name == "dl"
+            s.previous_element << s.next_element.remove
+            s.remove
+          end
+        end
+      end
+
+      # examples containing only figures become subfigures of figures
+      def subfigure_cleanup(xmldoc)
+        nodes = xmldoc.xpath("//example/figure")
+        while !nodes.empty?
+          nodes[0].parent.name = "figure"
+          nodes = xmldoc.xpath("//example/figure")
+        end
+      end
+
+      def figure_cleanup(xmldoc)
+        figure_footnote_cleanup(xmldoc)
+        figure_dl_cleanup(xmldoc)
+        subfigure_cleanup(xmldoc)
+      end
+
+      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
+      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
+    end
+  end
+end