asciidoctor-iso 0.0.1

data/lib/asciidoctor/iso/converter.rb

@@ -0,0 +1,53 @@
+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/table"
+require "asciidoctor/iso/validate"
+require "asciidoctor/iso/utils"
+
+module Asciidoctor
+  module ISO
+    # A {Converter} implementation that generates ISO output, and a document
+    # schema encapsulation of the document for validation
+    class Converter
+      include ::Asciidoctor::Converter
+      include ::Asciidoctor::Writer
+
+      include ::Asciidoctor::ISO::Base
+      include ::Asciidoctor::ISO::Front
+      include ::Asciidoctor::ISO::Lists
+      include ::Asciidoctor::ISO::InlineAnchor
+      include ::Asciidoctor::ISO::Blocks
+      include ::Asciidoctor::ISO::Table
+      include ::Asciidoctor::ISO::Utils
+      include ::Asciidoctor::ISO::Validate
+
+      register_for "iso"
+
+      $xreftext = {}
+
+      def initialize(backend, opts)
+        super
+        basebackend "html"
+        outfilesuffix ".xml"
+      end
+
+      # alias_method :pass, :content
+      alias_method :embedded, :content
+      alias_method :verse, :content
+      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
+      alias_method :inline_menu, :skip
+      alias_method :inline_image, :skip
+    end
+  end
+end

data/lib/asciidoctor/iso/front.rb

@@ -0,0 +1,80 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "json"
+require "pathname"
+require "open-uri"
+require "pp"
+
+module Asciidoctor
+  module ISO
+    module Front
+      def metadata_id(node, xml)
+        xml.id do |i|
+          i.documentnumber node.attr("docnumber"),
+            **attr_code(partnumber: 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")
+          end
+        end
+      end
+
+      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
+        end
+      end
+
+      def metadata_author(node, xml)
+        xml.author do |a|
+          a.technical_committee node.attr("technical-committee"),
+            **attr_code(number: node.attr("technical-committee-number"))
+          if node.attr("subcommittee")
+            a.subcommittee node.attr("subcommittee"),
+              **attr_code(number: node.attr("subcommittee-number"))
+          end
+          if node.attr("workgroup")
+            a.workgroup node.attr("workgroup"),
+              **attr_code(number: node.attr("workgroup-number"))
+          end
+          a.secretariat node.attr("secretariat") if node.attr("secretariat")
+        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")
+        end
+        metadata_id(node, xml)
+        xml.language node.attr("language")
+        metadata_version(node, xml)
+        metadata_author(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
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/iso/inline_anchor.rb

@@ -0,0 +1,65 @@
+module Asciidoctor
+  module ISO
+    module InlineAnchor
+      def inline_anchor(node)
+        case node.type
+        when :xref
+          inline_anchor_xref node
+        when :link
+          inline_anchor_link node
+        when :bibref
+          inline_anchor_bibref node
+        else
+          warn %(asciidoctor: WARNING (#{current_location(node)}): unknown anchor type: #{node.type.inspect})
+        end
+      end
+
+      def inline_anchor_xref(node)
+        matched = /^fn(:  (?<text>.*))?$/.match node.text
+        if matched.nil?
+          format = "inline"
+          xref_contents = node.text
+        else
+          format = "footnote"
+          xref_contents = matched[:text]
+        end
+        xref_attributes = {
+          target: node.target.gsub(/^#/, "").gsub(/(.)(\.xml)?#.*$/, "\\1"),
+          format: format,
+        }
+
+        noko do |xml|
+          xml.xref xref_contents, **attr_code(xref_attributes)
+        end.join
+      end
+
+      def inline_anchor_link(node)
+        eref_contents = node.target == node.text ? nil : node.text
+        eref_attributes = {
+          target: node.target,
+        }
+
+        noko do |xml|
+          xml.eref eref_contents, **attr_code(eref_attributes)
+        end.join
+      end
+
+      def inline_anchor_bibref(node)
+        eref_contents = node.target == node.text ? nil : node.text
+        eref_attributes = {
+          anchor: node.target,
+        }
+
+        noko do |xml|
+          xml.ref eref_contents, **attr_code(eref_attributes)
+        end.join
+      end
+
+      def inline_callout(node)
+        noko do |xml|
+          xml.ref node.text
+        end.join
+      end
+    end
+  end
+end

data/lib/asciidoctor/iso/lists.rb

@@ -0,0 +1,158 @@
+require "pp"
+module Asciidoctor
+  module ISO
+    module Lists
+      def ulist(node)
+        return norm_ref(node) if $norm_ref
+        return biblio_ref(node) if $biblio
+        noko do |xml|
+          xml.ul **attr_code(anchor: node.id) do |xml_ul|
+            node.items.each do |item|
+              xml_ul.li **attr_code(anchor: item.id) do |xml_li|
+                if item.blocks?
+                  xml_li.p { |t| t << item.text }
+                  xml_li << item.content
+                else
+                  xml_li.p { |p| p << item.text }
+                end
+              end
+            end
+          end
+        end.join
+      end
+
+      def isorefmatches(xml, matched)
+        ref_attributes = {
+          anchor: matched[:anchor],
+        }
+        xml.iso_ref_title **attr_code(ref_attributes) do |t|
+          t.isocode matched[:code]
+          t.isodate matched[:year] if matched[:year]
+          t.isotitle { |i| i << ref_normalise(matched[:text]) }
+        end
+      end
+
+      def isorefmatches2(xml, matched2)
+        ref_attributes = {
+          anchor: matched2[:anchor],
+        }
+        xml.iso_ref_title **attr_code(ref_attributes) do |t|
+          t.isocode matched2[:code]
+          t.isodate "--"
+          t.date_footnote matched2[:fn]
+          t.isotitle { |i| i << ref_normalise(matched2[:text]) }
+        end
+      end
+
+      def ref_normalise(ref)
+        ref.gsub(/&#8201;&#8212;&#8201;/, " -- ").
+          gsub(/&amp;amp;/, "&amp;")
+      end
+
+      def norm_ref(node)
+        noko do |xml|
+          node.items.each do |item|
+            matched = %r{^<ref\sanchor="(?<anchor>[^"]+)">
+            \[ISO\s(?<code>[0-9-]+)(:(?<year>[0-9]+))?\]</ref>,?\s
+            (?<text>.*)$}x.match item.text
+            matched2 = %r{^<ref\sanchor="(?<anchor>[^"]+)">
+            \[ISO\s(?<code>[0-9-]+):--\]</ref>,?\s?
+            <fn>(?<fn>[^\]]+)</fn>,?\s?(?<text>.*)$}x.match item.text
+            if matched2.nil?
+              if matched.nil?
+                warn %(asciidoctor: WARNING (#{current_location(node)}): normative reference not in expected format: #{item.text})
+              else
+                isorefmatches(xml, matched)
+              end
+            else
+              isorefmatches2(xml, matched2)
+            end
+          end
+        end.join
+      end
+
+      def biblio_ref(node)
+        noko do |xml|
+          node.items.each do |item|
+            matched = %r{^<ref\sanchor="(?<anchor>[^"]+)">
+            \[ISO\s(?<code>[0-9-]+)(:(?<year>[0-9]+))?\]</ref>,?\s
+            (?<text>.*)$}.match item.text
+            matched2 = %r{^<ref\sanchor="(?<anchor>[^"]+)">
+            \[ISO\s(?<code>[0-9-]+):--\]</ref>,?\s?
+            <fn>(?<fn>[^\]]+)</fn>,?\s?(?<text>.*)$}.match item.text
+            if matched2.nil?
+              if matched.nil?
+                xml.reference do |t|
+                  t.p { |p| p << ref_normalise(item.text) }
+                end
+              else
+                isorefmatches(xml, matched)
+              end
+            else
+              isorefmatches2(xml, matched2)
+            end
+          end
+        end.join
+      end
+
+      def olist(node)
+        noko do |xml|
+          xml.ol **attr_code(anchor: node.id, type: node.style) do |xml_ol|
+            node.items.each do |item|
+              xml_ol.li **attr_code(anchor: item.id) do |xml_li|
+                if item.blocks?
+                  xml_li.p { |t| t << item.text }
+                  xml_li << item.content
+                else
+                  xml_li.p { |p| p << item.text }
+                end
+              end
+            end
+          end
+        end.join
+      end
+
+      def dlist(node)
+        noko do |xml|
+          xml.dl **attr_code(anchor: node.id) do |xml_dl|
+            node.items.each do |terms, dd|
+              terms.each_with_index do |dt, idx|
+                xml_dl.dt { |xml_dt| xml_dt << dt.text }
+                if idx < terms.size - 1
+                  xml_dl.dd
+                end
+              end
+
+              if dd.nil?
+                xml_dl.dd
+              else
+                xml_dl.dd do |xml_dd|
+                  if dd.blocks?
+                    if dd.text?
+                      xml_dd.p { |t| t << dd.text }
+                    end
+                    xml_dd << dd.content
+                  else
+                    xml_dd.p { |t| t << dd.text }
+                  end
+                end
+              end
+            end
+          end
+        end.join
+      end
+
+      def colist(node)
+        noko do |xml|
+          xml.colist **attr_code(anchor: node.id) do |xml_ul|
+            node.items.each_with_index do |item, i|
+              xml_ul.annotation **attr_code(id: i + 1) do |xml_li|
+                xml_li << item.text
+              end
+            end
+          end
+        end.join
+      end
+    end
+  end
+end

data/lib/asciidoctor/iso/table.rb

@@ -0,0 +1,53 @@
+module Asciidoctor
+  module ISO
+    module Table
+      def table(node)
+        noko do |xml|
+          has_body = false
+          xml.table **attr_code(anchor: node.id) do |xml_table|
+            %i(head body foot).reject do |tblsec|
+              node.rows[tblsec].empty?
+            end.each do |tblsec|
+              has_body = true if tblsec == :body
+            end
+            xml_table.name node.title if node.title?
+            table_head_body_and_foot node, xml_table
+          end
+        end
+      end
+
+      private
+
+      def table_head_body_and_foot(node, xml)
+        %i(head body foot).reject do |tblsec|
+          node.rows[tblsec].empty?
+        end.each do |tblsec|
+          tblsec_tag = "t#{tblsec}"
+          # "anchor" attribute from tblsec.id not supported
+          xml.send tblsec_tag do |xml_tblsec|
+            node.rows[tblsec].each_with_index do |row, i|
+              xml_tblsec.tr do |xml_tr|
+                rowlength = 0
+                row.each do |cell|
+                  cell_attributes = {
+                    anchor: cell.id,
+                    colspan: cell.colspan,
+                    rowspan: cell.rowspan,
+                    align: cell.attr("halign"),
+                  }
+
+                  cell_tag = "td"
+                  cell_tag = "th" if tblsec == :head || cell.style == :header
+                  rowlength += cell.text.size
+                  xml_tr.send cell_tag, **attr_code(cell_attributes) do |thd|
+                    thd << (cell.style == :asciidoc ? cell.content : cell.text)
+                  end
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/iso/utils.rb

@@ -0,0 +1,224 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "json"
+require "pathname"
+require "open-uri"
+require "pp"
+
+module Asciidoctor
+  module ISO
+    module Utils
+      def convert(node, transform = nil, opts = {})
+        transform ||= node.node_name
+        opts.empty? ? (send transform, node) : (send transform, node, opts)
+      end
+
+      def document_ns_attributes(_doc)
+        # ' xmlns="http://riboseinc.com/isoxml"'
+        nil
+      end
+
+      def cleanup(xmldoc)
+        intro_cleanup(xmldoc)
+        termdef_cleanup(xmldoc)
+        isotitle_cleanup(xmldoc)
+        tablenote_cleanup(xmldoc)
+        formula_cleanup(xmldoc)
+        figure_cleanup(xmldoc)
+        back_cleanup(xmldoc)
+        ref_cleanup(xmldoc)
+      end
+
+      def intro_cleanup(xmldoc)
+        intro = xmldoc.at("//introduction")
+        foreword = xmldoc.at("//foreword")
+        front = xmldoc.at("//front")
+        unless foreword.nil? || front.nil?
+          foreword.remove
+          front << foreword
+        end
+        unless intro.nil? || front.nil?
+          intro.remove
+          front << intro
+        end
+      end
+
+      def termdef_cleanup(xmldoc)
+        # release termdef tags from surrounding paras
+        nodes = xmldoc.xpath("//p/admitted_term | //p/termsymbol |
+                             //p/deprecated_term")
+        while !nodes.empty?
+          nodes[0].parent.replace(nodes[0].parent.children)
+          nodes = xmldoc.xpath("//p/admitted_term | //p/termsymbol |
+                               //p/deprecated_term")
+        end
+        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("termsymbol", xmldoc)
+            parent = a.parent
+            a.remove
+            t.children = a
+            parent.replace(t)
+          end
+        end
+        xmldoc.xpath("//p/termdomain").each do |a|
+          prev = a.parent.previous
+          a.remove
+          prev.next = a
+        end
+      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 tablenote_cleanup(xmldoc)
+        # move notes after table footer
+        xmldoc.xpath("//tfoot/tr/td/note | //tfoot/tr/th/note").each do |n|
+          target = n.parent.parent.parent.parent
+          n.remove
+          target << n
+        end
+      end
+
+      def formula_cleanup(xmldoc)
+        # include where definition list inside stem block
+        xmldoc.xpath("//formula").each do |s|
+          if !s.next_element.nil? && s.next_element.name == "p" &&
+              s.next_element.content == "where" &&
+              !s.next_element.next_element.nil? &&
+              s.next_element.next_element.name == "dl"
+            dl = s.next_element.next_element.remove
+            s.next_element.remove
+            s << dl
+          end
+        end
+      end
+
+      def figure_cleanup(xmldoc)
+        # include key definition list inside figure
+        xmldoc.xpath("//figure").each do |s|
+          if !s.next_element.nil? && s.next_element.name == "p" &&
+              s.next_element.content =~ /^\s*Key\s*$/m &&
+              !s.next_element.next_element.nil? &&
+              s.next_element.next_element.name == "dl"
+            dl = s.next_element.next_element.remove
+            s.next_element.remove
+            s << dl
+          end
+        end
+
+        # 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 back_cleanup(xmldoc)
+        # move annex/bibliography to back
+        if !xmldoc.xpath("//annex | //bibliography").empty?
+          b = Nokogiri::XML::Element.new("back", xmldoc)
+          xmldoc.root << b
+          xmldoc.xpath("//annex").each do |e|
+            e.remove
+            b << e
+          end
+          xmldoc.xpath("//bibliography").each do |e|
+            e.remove
+            b << e
+          end
+        end
+      end
+
+      def ref_cleanup(xmldoc)
+        # move ref before p
+        xmldoc.xpath("//p/ref").each do |r|
+          parent = r.parent
+          r.remove
+          parent.previous = r
+        end
+
+        xmldoc
+      end
+
+      # block for processing XML document fragments as XHTML,
+      # to allow for HTMLentities
+      def noko(&block)
+        # fragment = ::Nokogiri::XML::DocumentFragment.parse("")
+        # fragment.doc.create_internal_subset("xml", nil, "xhtml.dtd")
+        head = <<HERE
+        <!DOCTYPE html SYSTEM
+        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+        <html xmlns="http://www.w3.org/1999/xhtml">
+        <head> <title></title> <meta charset="UTF-8" /> </head>
+        <body> </body> </html>
+HERE
+        doc = ::Nokogiri::XML.parse(head)
+        fragment = doc.fragment("")
+        ::Nokogiri::XML::Builder.with fragment, &block
+        fragment.to_xml(encoding: "US-ASCII").lines.map do |l|
+          l.gsub(/\s*\n/, "")
+        end
+      end
+
+      def attr_code(attributes)
+        attributes = attributes.reject { |_, val| val.nil? }.map
+        attributes.map do |k, v|
+          [k, (v.is_a? String) ? HTMLEntities.new.decode(v) : v]
+        end.to_h
+      end
+
+      def current_location(node)
+        if node.respond_to?(:lineno) && !node.lineno.nil? &&
+            !node.lineno.empty?
+          return "Line #{node.lineno}"
+        end
+        if node.respond_to?(:id) && !node.id.nil?
+          return "ID #{node.id}"
+        end
+        while !node.nil? && (!node.respond_to?(:level) ||
+            node.level.positive?) && node.context != :section
+          node = node.parent
+          if !node.nil? && node.context == :section
+            return "Section: #{node.title}"
+          end
+        end
+        "??"
+      end
+
+      # if node contains blocks, flatten them into a single line;
+      # and extract only raw text
+      def flatten_rawtext(node)
+        result = []
+        if node.respond_to?(:blocks) && node.blocks?
+          node.blocks.each { |b| result << flatten_rawtext(b) }
+        elsif node.respond_to?(:lines)
+          node.lines.each do |x|
+            if node.respond_to?(:context) && (node.context == :literal ||
+                node.context == :listing)
+              result << x.gsub(/</, "&lt;").gsub(/>/, "&gt;")
+            else
+              # strip not only HTML tags <tag>,
+              # but also Asciidoc crossreferences <<xref>>
+              result << x.gsub(/<[^>]*>+/, "")
+            end
+          end
+        elsif node.respond_to?(:text)
+          result << node.text.gsub(/<[^>]*>+/, "")
+        else
+          result << node.content.gsub(/<[^>]*>+/, "")
+        end
+        result.reject(&:empty?)
+      end
+    end
+  end
+end