metanorma-standoc 0.0.1

data/lib/asciidoctor/standoc/cleanup_footnotes.rb

@@ -0,0 +1,78 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "json"
+require "pathname"
+require "open-uri"
+require "pp"
+
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      # 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 table_footnote_renumber1(fn, i, seen)
+        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
+        [i, seen]
+      end
+
+      def table_footnote_renumber(xmldoc)
+        xmldoc.xpath("//table | //figure").each do |t|
+          seen = {}
+          i = 0
+          t.xpath(".//fn").each do |fn|
+            i, seen = table_footnote_renumber1(fn, i, seen)
+          end
+        end
+      end
+
+      def other_footnote_renumber1(fn, i, seen)
+        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
+        [i, seen]
+      end
+
+      def other_footnote_renumber(xmldoc)
+        seen = {}
+        i = 0
+        xmldoc.xpath("//fn").each do |fn|
+          i, seen = other_footnote_renumber1(fn, i, seen)
+        end
+      end
+
+      def footnote_renumber(xmldoc)
+        table_footnote_renumber(xmldoc)
+        other_footnote_renumber(xmldoc)
+        xmldoc.xpath("//fn").each do |fn|
+          fn.delete("table")
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/cleanup_ref.rb

@@ -0,0 +1,125 @@
+module Asciidoctor
+  module Standoc
+    module Cleanup
+      # extending localities to cover ISO referencing
+      LOCALITY_REGEX_STR = <<~REGEXP.freeze
+        ^((?<locality>section|clause|part|paragraph|chapter|page|
+                      table|annex|figure|example|note|formula|
+                      locality:[^ \\t\\n\\r:,]+)(\\s+|=)
+               (?<ref>[^"][^ \\t\\n,:-]*|"[^"]+")
+                 (-(?<to>[^"][^ \\t\\n,:-]*|"[^"]"))?|
+          (?<locality2>whole|locality:[^ \\t\\n\\r:,]+))[,:]?\\s*
+         (?<text>.*)$
+      REGEXP
+      LOCALITY_RE = Regexp.new(LOCALITY_REGEX_STR.gsub(/\s/, ""),
+                               Regexp::IGNORECASE | Regexp::MULTILINE)
+
+      def tq(x)
+        x.sub(/^"/, "").sub(/"$/, "")
+      end
+
+      def extract_localities(x)
+        text = x.children.first.remove.text
+        while (m = LOCALITY_RE.match text)
+          ref = m[:ref] ? "<referenceFrom>#{tq m[:ref]}</referenceFrom>" : ""
+          refto = m[:to] ? "<referenceTo>#{tq m[:to]}</referenceTo>" : ""
+          loc = m[:locality]&.downcase || m[:locality2]&.downcase
+          x.add_child("<locality type='#{loc}'>#{ref}#{refto}</locality>")
+          text = m[:text]
+        end
+        x.add_child(text)
+      end
+
+      def xref_to_eref(x)
+        x["bibitemid"] = x["target"]
+        x["citeas"] = @anchors&.dig(x["target"], :xref) ||
+          warn("ISO: #{x['target']} is not a real reference!")
+        x.delete("target")
+        extract_localities(x) unless x.children.empty?
+      end
+
+      def xref_cleanup(xmldoc)
+        xmldoc.xpath("//xref").each do |x|
+          if refid? x["target"]
+            x.name = "eref"
+            xref_to_eref(x)
+          else
+            x.delete("type")
+          end
+        end
+      end
+
+      # allows us to deal with doc relation localities,
+      # temporarily stashed to "bpart"
+      def bpart_cleanup(xmldoc)
+        xmldoc.xpath("//relation/bpart").each do |x|
+          extract_localities(x)
+          x.replace(x.children)
+        end
+      end
+
+      def quotesource_cleanup(xmldoc)
+        xmldoc.xpath("//quote/source | //terms/source").each do |x|
+          xref_to_eref(x)
+        end
+      end
+
+      def origin_cleanup(xmldoc)
+        xmldoc.xpath("//origin").each do |x|
+          x["citeas"] = @anchors&.dig(x["bibitemid"], :xref) ||
+            warn("ISO: #{x['bibitemid']} is not a real reference!")
+          extract_localities(x) unless x.children.empty?
+        end
+      end
+
+      # move ref before p
+      def ref_cleanup(xmldoc)
+        xmldoc.xpath("//p/ref").each do |r|
+          parent = r.parent
+          parent.previous = r.remove
+        end
+      end
+
+      def normref_cleanup(xmldoc)
+        q = "//references[title = 'Normative References']"
+        r = xmldoc.at(q) || return
+        r.elements.each do |n|
+          n.remove unless ["title", "bibitem"].include? n.name
+        end
+      end
+
+      def format_ref(ref, isopub)
+        return ref if isopub
+        return "[#{ref}]" if /^\d+$/.match(ref) && !/^\[.*\]$/.match(ref)
+        ref
+      end
+
+      ISO_PUBLISHER_XPATH =
+        "./contributor[role/@type = 'publisher']/"\
+        "organization[abbreviation = 'ISO' or abbreviation = 'IEC' or "\
+        "name = 'International Organization for Standardization' or "\
+        "name = 'International Electrotechnical Commission']".freeze
+
+      def date_range(date)
+        from = date.at("./from")
+        to = date.at("./to")
+        on = date.at("./on")
+        return on.text if on
+        ret = "#{from.text}&ndash;"
+        ret += to.text if to
+        ret
+      end
+
+      def reference_names(xmldoc)
+        xmldoc.xpath("//bibitem[not(ancestor::bibitem)]").each do |ref|
+          isopub = ref.at(ISO_PUBLISHER_XPATH)
+          docid = ref.at("./docidentifier")
+          date = ref.at("./date[@type = 'published']")
+          reference = format_ref(docid.text, isopub)
+          reference += ":#{date_range(date)}" if date
+          @anchors[ref["id"]] = { xref: reference }
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/converter.rb

@@ -0,0 +1,55 @@
+require "asciidoctor"
+require "asciidoctor/standoc/version"
+require "asciidoctor/standoc/base"
+require "asciidoctor/standoc/front"
+require "asciidoctor/standoc/lists"
+require "asciidoctor/standoc/ref"
+require "asciidoctor/standoc/inline"
+require "asciidoctor/standoc/blocks"
+require "asciidoctor/standoc/section"
+require "asciidoctor/standoc/table"
+require "asciidoctor/standoc/validate"
+require "asciidoctor/standoc/utils"
+require "asciidoctor/standoc/cleanup"
+require_relative "./macros.rb"
+
+module Asciidoctor
+  module Standoc
+    # A {Converter} implementation that generates Standoc output, and a document
+    # schema encapsulation of the document for validation
+    class Converter
+      include ::Asciidoctor::Converter
+      include ::Asciidoctor::Writer
+
+      include ::Asciidoctor::Standoc::Base
+      include ::Asciidoctor::Standoc::Front
+      include ::Asciidoctor::Standoc::Lists
+      include ::Asciidoctor::Standoc::Inline
+      include ::Asciidoctor::Standoc::Blocks
+      include ::Asciidoctor::Standoc::Section
+      include ::Asciidoctor::Standoc::Table
+      include ::Asciidoctor::Standoc::Utils
+      include ::Asciidoctor::Standoc::Cleanup
+      include ::Asciidoctor::Standoc::Validate
+
+      register_for "standoc"
+
+      $xreftext = {}
+
+      def initialize(backend, opts)
+        super
+        basebackend "html"
+        outfilesuffix ".xml"
+      end
+
+      alias_method :embedded, :content
+      alias_method :verse, :quote
+      alias_method :audio, :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/standoc/front.rb

@@ -0,0 +1,121 @@
+require "date"
+require "nokogiri"
+require "htmlentities"
+require "json"
+require "pathname"
+require "open-uri"
+require "pp"
+
+module Asciidoctor
+  module Standoc
+    module Front
+      def metadata_id(node, xml)
+        part, subpart = node&.attr("partnumber")&.split(/-/)
+        xml.docidentifier do |i|
+          i.project_number node.attr("docnumber"),
+            **attr_code(part: part, subpart: subpart)
+        end
+      end
+
+      def metadata_version(node, xml)
+        xml.version do |v|
+          v.edition node.attr("edition") if node.attr("edition")
+          v.revision_date node.attr("revdate") if node.attr("revdate")
+          v.draft node.attr("draft") if node.attr("draft")
+        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"))
+      end
+
+      def organization(org, orgname)
+          org.name orgname
+      end
+
+      def metadata_author(node, xml)
+        publishers = node.attr("publisher") || return
+        publishers.split(/,[ ]?/).each do |p|
+          xml.contributor do |c|
+            c.role **{ type: "author" }
+            c.organization { |a| organization(a, p) }
+          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|
+          xml.copyright do |c|
+            c.from (node.attr("copyright-year") || Date.today.year)
+            p.match(/[A-Za-z]/).nil? or c.owner do |owner|
+              owner.organization { |o| organization(o, p) }
+            end
+          end
+        end
+      end
+
+      def metadata_status(node, xml)
+        xml.status(**{ format: "plain" }) do |s|
+          s << ( node.attr("status") || "published" )
+        end
+      end
+
+      def metadata_committee(node, xml)
+        xml.editorialgroup do |a|
+          committee_component("technical-committee", node, a)
+        end
+      end
+
+      def metadata_ics(node, xml)
+        ics = node.attr("library-ics")
+        ics && ics.split(/,\s*/).each do |i|
+          xml.ics do |ics|
+            ics.code i
+          end
+        end
+      end
+
+      def metadata(node, xml)
+        title node, xml
+        metadata_id(node, xml)
+        metadata_author(node, xml)
+        metadata_publisher(node, xml)
+        xml.language (node.attr("language") || "en")
+        xml.script (node.attr("script") || "Latn")
+        metadata_status(node, xml)
+        metadata_copyright(node, xml)
+        metadata_committee(node, xml)
+        metadata_ics(node, xml)
+      end
+
+      def asciidoc_sub(x)
+        return nil if x.nil?
+        d = Asciidoctor::Document.new(x.lines.entries, {header_footer: false})
+        b = d.parse.blocks.first
+        b.apply_subs(b.source)
+      end
+
+      def title(node, xml)
+        ["en"].each do |lang|
+          at = { language: lang, format: "text/plain" }
+          xml.title **attr_code(at) do |t|
+            t << asciidoc_sub(node.attr("title"))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/asciidoctor/standoc/inline.rb

@@ -0,0 +1,134 @@
+require "asciidoctor/extensions"
+require "htmlentities"
+
+module Asciidoctor
+  module Standoc
+    module Inline
+      def refid?(x)
+        @refids.include? x
+      end
+
+      def inline_anchor(node)
+        case node.type
+        when :ref
+          inline_anchor_ref node
+        when :xref
+          inline_anchor_xref node
+        when :link
+          inline_anchor_link node
+        when :bibref
+          inline_anchor_bibref node
+        end
+      end
+
+      def inline_anchor_ref(node)
+        noko do |xml|
+          xml.bookmark nil, **attr_code(id: node.id)
+        end.join
+      end
+
+      def inline_anchor_xref(node)
+        matched = /^fn(:\s*(?<text>.*))?$/.match node.text
+        f = matched.nil? ? "inline" : "footnote"
+        c = matched.nil? ? node.text : matched[:text]
+        t = node.target.gsub(/^#/, "").gsub(%r{(.)(\.xml)?#.*$}, "\\1")
+        noko do |xml|
+          xml.xref **attr_code(target: t, type: f) do |x|
+            x << c
+          end
+        end.join
+      end
+
+      def inline_anchor_link(node)
+        contents = node.text
+        contents = "" if node.target.gsub(%r{^mailto:}, "") == node.text
+        attributes = { "target": node.target }
+        noko do |xml|
+          xml.link **attr_code(attributes) do |l|
+            l << contents
+          end
+        end.join
+      end
+
+      def inline_anchor_bibref(node)
+        eref_contents = node.target == node.text ? nil : node.text
+        eref_attributes = { id: node.target }
+        @refids << node.target
+        noko do |xml|
+          xml.ref **attr_code(eref_attributes) do |r|
+            r << eref_contents
+          end
+        end.join
+      end
+
+      def inline_callout(node)
+        noko do |xml|
+          xml.callout node.text
+        end.join
+      end
+
+      def inline_footnote(node)
+        noko do |xml|
+          @fn_number += 1
+          xml.fn **{ reference: @fn_number } do |fn|
+            fn.p { |p| p << node.text }
+          end
+        end.join("\n")
+      end
+
+      def inline_break(node)
+        noko do |xml|
+          xml << node.text
+          xml.br
+        end.join("\n")
+      end
+
+      def page_break(_node)
+        noko { |xml| xml.pagebreak }.join("\n")
+      end
+
+      def thematic_break(_node)
+        noko { |xml| xml.hr }.join("\n")
+      end
+
+      def stem_parse(text, xml)
+        if /&lt;([^:>&]+:)?math(\s+[^>&]+)?&gt; |
+          <([^:>&]+:)?math(\s+[^>&]+)?>/x.match text
+          math = HTMLEntities.new.encode(text, :basic, :hexadecimal).
+            gsub(/&amp;gt;/, ">").gsub(/\&amp;lt;/, "<").gsub(/&amp;amp;/, "&").
+            gsub(/&gt;/, ">").gsub(/&lt;/, "<").gsub(/&amp;/, "&")
+          xml.stem math, **{ type: "MathML" }
+        else
+          xml.stem text, **{ type: "AsciiMath" }
+        end
+      end
+
+      def inline_quoted(node)
+        noko do |xml|
+          case node.type
+          when :emphasis then xml.em node.text
+          when :strong then xml.strong node.text
+          when :monospaced then xml.tt node.text
+          when :double then xml << "\"#{node.text}\""
+          when :single then xml << "'#{node.text}'"
+          when :superscript then xml.sup node.text
+          when :subscript then xml.sub node.text
+          when :asciimath then stem_parse(node.text, xml)
+          else
+            case node.role
+              # the following three are legacy, they are now handled by macros
+            when "alt" then xml.admitted { |a| a << node.text }
+            when "deprecated" then xml.deprecates { |a| a << node.text }
+            when "domain" then xml.domain { |a| a << node.text }
+
+            when "strike" then xml.strike node.text
+            when "smallcap" then xml.smallcap node.text
+            else
+              xml << node.text
+            end
+          end
+        end.join
+      end
+    end
+  end
+end