asciidoctor-iso 0.0.1 → 0.6.0

data/lib/asciidoctor/iso/cleanup.rb

@@ -0,0 +1,214 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "json"
+require "pathname"
+require "open-uri"
+require "pp"
+require_relative "./cleanup_block.rb"
+
+module Asciidoctor
+  module ISO
+    module Cleanup
+      def textcleanup(text)
+        text.gsub(/\s+<fn /, "<fn ")
+      end
+
+      def cleanup(xmldoc)
+        termdef_cleanup(xmldoc)
+        isotitle_cleanup(xmldoc)
+        table_cleanup(xmldoc)
+        formula_cleanup(xmldoc)
+        figure_cleanup(xmldoc)
+        ref_cleanup(xmldoc)
+        review_note_cleanup(xmldoc)
+        normref_cleanup(xmldoc)
+        xref_cleanup(xmldoc)
+        para_cleanup(xmldoc)
+        callout_cleanup(xmldoc)
+        origin_cleanup(xmldoc)
+        element_name_cleanup(xmldoc)
+        footnote_renumber(xmldoc)
+        xmldoc
+      end
+
+      def element_name_cleanup(xmldoc)
+        xmldoc.traverse { |n| n.name = n.name.gsub(/_/, "-") }
+      end
+
+      def callout_cleanup(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
+            callouts.each_with_index do |c, i|
+              c["target"] = UUIDTools::UUID.random_create
+              annotations[i]["id"] = c["id"]
+            end
+          else
+            warn "#{x["id"]}: mismatch of callouts and annotations"
+          end
+        end
+      end
+
+      def xref_cleanup(xmldoc)
+        reference_names(xmldoc)
+        xmldoc.xpath("//xref").each do |x|
+          #if InlineAnchor::is_refid? x["target"]
+          if is_refid? x["target"]
+            x.name = "eref"
+            x["bibitemid"] = x["target"]
+            x["citeas"] = @anchors[x["target"]][:xref]
+            x.delete("target")
+          else
+            x.delete("type")
+          end
+        end
+      end
+
+      def origin_cleanup(xmldoc)
+        xmldoc.xpath("//origin").each do |x|
+          x["citeas"] = @anchors[x["bibitemid"]][:xref]
+          n = x.next_element
+          if !n.nil? && n.name == "isosection"
+            n.name = "locality"
+            n["type"] = "section"
+            n.parent = x
+          end
+        end
+      end
+
+      def termdef_warn(text, re, term, msg)
+        if re.match? text
+          warn "ISO style: #{term}: #{msg}"
+        end
+      end
+
+      def termdef_style(xmldoc)
+        xmldoc.xpath("//term").each do |t|
+          para = t.at("./p") or return
+          term = t.at("preferred").text
+          termdef_warn(para.text, /^(the|a)\b/i, term,
+                       "term definition starts with article")
+          termdef_warn(para.text, /\.$/i, term,
+                       "term definition ends with period")
+        end
+      end
+
+      def termdef_stem_cleanup(xmldoc)
+        xmldoc.xpath("//termdef/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") or return
+          t = Nokogiri::XML::Element.new("definition", xmldoc)
+          first_child.replace(t)
+          t << first_child.remove
+          d.xpath("./p | ./figure | ./formula").each do |n|
+            t << n.remove
+          end
+        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_cleanup(xmldoc)
+        termdef_unnest_cleanup(xmldoc)
+        termdef_stem_cleanup(xmldoc)
+        termdomain_cleanup(xmldoc)
+        termdefinition_cleanup(xmldoc)
+        termdef_style(xmldoc)
+      end
+
+      def isotitle_cleanup(xmldoc)
+        # Remove italicised ISO titles
+        xmldoc.xpath("//isotitle").each do |a|
+          if a.elements.size == 1 && a.elements[0].name == "em"
+            a.children = a.elements[0].children
+          end
+        end
+      end
+
+      def dl_table_cleanup(xmldoc)
+        # move Key dl after table footer
+        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 ref_cleanup(xmldoc)
+        # move ref before p
+        xmldoc.xpath("//p/ref").each do |r|
+          parent = r.parent
+          parent.previous = r.remove
+        end
+        xmldoc
+      end
+
+      def review_note_cleanup(xmldoc)
+        xmldoc.xpath("//review").each do |n|
+          prev = n.previous_element
+          if !prev.nil? && prev.name == "p"
+            n.parent = prev
+          end
+        end
+      end
+
+      def normref_cleanup(xmldoc)
+        q = "//references[title = 'Normative References']"
+        r = xmldoc.at(q)
+        r.elements.each do |n|
+          unless ["title", "bibitem"].include? n.name
+            n.remove
+          end
+        end
+      end
+
+      def format_ref(ref, isopub)
+        return "ISO #{ref}" if isopub
+        return "[#{ref}]" if /^\d+$/.match?(ref) && !/^\[.*\]$/.match?(ref) 
+        ref
+      end
+
+      def reference_names(xmldoc)
+        xmldoc.xpath("//bibitem").each do |ref|
+          isopub = ref.at(("./publisher/affiliation[name = 'ISO']"))
+          docid = ref.at(("./docidentifier"))
+          date = ref.at(("./publisherdate"))
+          reference = format_ref(docid.text, isopub)
+          reference += ": #{date.text}" if date && isopub
+          @anchors[ref["id"]] = { xref: reference }
+        end
+      end
+
+    end
+  end
+end

data/lib/asciidoctor/iso/cleanup_block.rb

@@ -0,0 +1,157 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "json"
+require "pathname"
+require "open-uri"
+require "pp"
+
+module Asciidoctor
+  module ISO
+    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
+
+      def dl_table_cleanup(xmldoc)
+        # move Key dl after table footer
+        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 header_rows_cleanup(xmldoc)
+        q = "//table[@headerrows]"
+        xmldoc.xpath(q).each do |s|
+          thead = s.at("./thead")
+          [1..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
+
+      def notes_table_cleanup(xmldoc)
+        # move notes into table
+        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
+
+      def formula_cleanup(x)
+        # include where definition list inside stem block
+        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 footnotes inside figure
+      def figure_footnote_cleanup(xmldoc)
+        nomatches = false
+        until nomatches
+          q = "//figure/following-sibling::*[1][self::p and *[1][self::fn]]"
+          nomatches = true
+          xmldoc.xpath(q).each do |s|
+            s.previous_element << s.first_element_child.remove
+            s.remove
+            nomatches = false
+          end
+        end
+      end
+
+      def figure_dl_cleanup(xmldoc)
+        # include key definition list inside figure
+        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
+
+      def subfigure_cleanup(xmldoc)
+        # examples containing only figures become subfigures of figures
+        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 table_footnote_renumber(xmldoc)
+        xmldoc.xpath("//table | //figure").each do |t|
+          seen, i = {}, 0
+          t.xpath(".//fn").each do |fn|
+            if seen[fn.text] then outnum = seen[fn.text]
+            else
+              i += 1
+              outnum = i
+              seen[fn.text] = outnum
+            end
+            fn["reference"] = (outnum - 1 + 'a'.ord).chr
+            fn["table"] = true
+          end
+        end
+      end
+
+      def other_footnote_renumber(xmldoc)
+        seen, i = {}, 0
+        xmldoc.xpath("//fn | //bibitem/note").each do |fn|
+          unless fn["table"]
+            if seen[fn.text] then outnum = seen[fn.text]
+            else
+              i += 1
+              outnum = i
+              seen[fn.text] = outnum
+            end
+            fn["reference"] = outnum.to_s
+          end
+          fn.delete("table")
+        end
+      end
+
+      def footnote_renumber(xmldoc)
+        table_footnote_renumber(xmldoc)
+        other_footnote_renumber(xmldoc)
+      end
+
+    end
+  end
+end

data/lib/asciidoctor/iso/converter.rb

@@ -1,14 +1,15 @@
 require "asciidoctor"
-
 require "asciidoctor/iso/version"
 require "asciidoctor/iso/base"
 require "asciidoctor/iso/front"
 require "asciidoctor/iso/lists"
 require "asciidoctor/iso/inline_anchor"
 require "asciidoctor/iso/blocks"
+require "asciidoctor/iso/section"
 require "asciidoctor/iso/table"
 require "asciidoctor/iso/validate"
 require "asciidoctor/iso/utils"
+require "asciidoctor/iso/cleanup"
 
 module Asciidoctor
   module ISO
@@ -23,8 +24,10 @@ module Asciidoctor
       include ::Asciidoctor::ISO::Lists
       include ::Asciidoctor::ISO::InlineAnchor
       include ::Asciidoctor::ISO::Blocks
+      include ::Asciidoctor::ISO::Section
       include ::Asciidoctor::ISO::Table
       include ::Asciidoctor::ISO::Utils
+      include ::Asciidoctor::ISO::Cleanup
       include ::Asciidoctor::ISO::Validate
 
       register_for "iso"
@@ -39,10 +42,9 @@ module Asciidoctor
 
       # alias_method :pass, :content
       alias_method :embedded, :content
-      alias_method :verse, :content
+      alias_method :verse, :quote
       alias_method :literal, :content
       alias_method :audio, :skip
-      alias_method :thematic_break, :skip
       alias_method :video, :skip
       alias_method :inline_button, :skip
       alias_method :inline_kbd, :skip

data/lib/asciidoctor/iso/front.rb

@@ -11,13 +11,10 @@ module Asciidoctor
     module Front
       def metadata_id(node, xml)
         xml.id do |i|
-          i.documentnumber node.attr("docnumber"),
-            **attr_code(partnumber: node.attr("partnumber"))
+          i.project_number node.attr("docnumber"),
+            **attr_code(part: node.attr("partnumber"))
           if node.attr("tc-docnumber")
-            i.tc_documentnumber node.attr("tc-docnumber")
-          end
-          if node.attr("ref-docnumber")
-            i.ref_documentnumber node.attr("ref-docnumber")
+            i.tc_document_number node.attr("tc-docnumber")
           end
         end
       end
@@ -25,15 +22,13 @@ module Asciidoctor
       def metadata_version(node, xml)
         xml.version do |v|
           v.edition node.attr("edition") if node.attr("edition")
-          v.revdate node.attr("revdate") if node.attr("revdate")
-          if node.attr("copyright-year")
-            v.copyright_year node.attr("copyright-year")
-          end
+          v.revision_date node.attr("revdate") if node.attr("revdate")
+          v.draft node.attr("draft") if node.attr("draft")
         end
       end
 
       def metadata_author(node, xml)
-        xml.author do |a|
+        xml.creator **{ role: "author" } do |a|
           a.technical_committee node.attr("technical-committee"),
             **attr_code(number: node.attr("technical-committee-number"))
           if node.attr("subcommittee")
@@ -48,29 +43,43 @@ module Asciidoctor
         end
       end
 
-      def metadata(node, xml)
-        xml.documenttype node.attr("doctype")
-        xml.documentstatus do |s|
-          s.stage node.attr("docstage")
-          s.substage node.attr("docsubstage") if node.attr("docsubstage")
+      def metadata_copyright(node, xml)
+        from = node.attr("copyright-year") || Date.today.year
+        xml.copyright do |c|
+          c.from from
+          c.owner do |o|
+            o.affiliation "ISO"
+          end
         end
-        metadata_id(node, xml)
+      end
+
+      def metadata_status(node, xml)
+        xml.status do |s|
+          s.stage ( node.attr("docstage") || "60" )
+          s.substage ( node.attr("docsubstage") || "60" )
+        end
+      end
+
+      def metadata(node, xml)
+        metadata_status(node, xml)
+        metadata_author(node, xml)
         xml.language node.attr("language")
+        xml.script "latn"
+        xml.type node.attr("doctype")
+        metadata_id(node, xml)
         metadata_version(node, xml)
-        metadata_author(node, xml)
+        metadata_copyright(node, xml)
       end
 
       def title(node, xml)
-        xml.title do |t0|
-          ["en", "fr"].each do |lang|
-            t0.send lang do |t|
-              if node.attr("title-intro-#{lang}")
-                t.title_intro { |t1| t1 << node.attr("title-intro-#{lang}") }
-              end
-              t.title_main { |t1| t1 << node.attr("title-main-#{lang}") }
-              if node.attr("title-part-#{lang}")
-                t.title_part node.attr("title-part-#{lang}")
-              end
+        ["en", "fr"].each do |lang|
+          xml.title **{ language: lang } do |t|
+            if node.attr("title-intro-#{lang}")
+              t.title_intro { |t1| t1 << node.attr("title-intro-#{lang}") }
+            end
+            t.title_main { |t1| t1 << node.attr("title-main-#{lang}") }
+            if node.attr("title-part-#{lang}")
+              t.title_part node.attr("title-part-#{lang}")
             end
           end
         end