asciidoctor-iso 0.0.1 → 0.6.0

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/asciidoctor-iso.gemspec

@@ -10,7 +10,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Ribose Inc."]
   spec.email         = ["open.source@ribose.com"]
 
-  spec.summary       = "asciidoctor-iso lets you write ISO standards in AsciiDoc."
+  spec.summary       = "asciidoctor-iso lets you write ISO standards "\
+    "in AsciiDoc."
   spec.description   = <<~DESCRIPTION
     asciidoctor-iso lets you write ISO standards in AsciiDoc syntax.
 
@@ -24,12 +25,19 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
   spec.files         = `git ls-files`.split("\n")
   spec.test_files    = `git ls-files -- {spec}/*`.split("\n")
-  spec.required_ruby_version = Gem::Requirement.new(">= 2.3.0")
+  spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
 
   spec.add_dependency "asciidoctor", "~> 1.5.6"
+  spec.add_dependency "asciimath"
   spec.add_dependency "htmlentities", "~> 4.3.4"
-  spec.add_dependency "nokogiri", "~> 1.8.1"
+  spec.add_dependency "image_size"
+  spec.add_dependency "mime-types"
+  spec.add_dependency "nokogiri", "= 1.8.1"
+  spec.add_dependency "ruby-jing"
+  spec.add_dependency "ruby-xslt"
   spec.add_dependency "thread_safe"
+  spec.add_dependency "uuidtools"
+  spec.add_dependency "html2doc"
 
   spec.add_development_dependency "bundler", "~> 1.15"
   spec.add_development_dependency "byebug", "~> 9.1"

data/lib/asciidoctor/iso/base.rb

@@ -5,86 +5,150 @@ require "json"
 require "pathname"
 require "open-uri"
 require "pp"
+require "isodoc"
 
 module Asciidoctor
   module ISO
     module Base
+
       def content(node)
         node.content
       end
 
       def skip(node, name = nil)
-        warn %(asciidoctor: WARNING (#{current_location(node)}): \
-          converter missing for #{name || node.node_name} node in ISO backend)
+        name = name || node.node_name
+        w = "converter missing for #{name} node in ISO backend"
+        warning(node, w, nil)
         nil
       end
 
+      def html_doc_path(file)
+        File.join(File.dirname(__FILE__), File.join("html", file))
+      end
+
+      def doc_converter
+        IsoDoc::Convert.new(
+          htmlstylesheet: html_doc_path("htmlstyle.css"),
+          wordstylesheet: nil,
+          standardstylesheet: html_doc_path("isodoc.css"),
+          header: html_doc_path("header.html"),
+          htmlcoverpage: html_doc_path("html_iso_titlepage.html"),
+          wordcoverpage: html_doc_path("word_iso_titlepage.html"),
+          htmlintropage: html_doc_path("html_iso_intro.html"),
+          wordintropage: html_doc_path("word_iso_intro.html"),
+        )
+      end
+
+      def init
+        @fn_number = 0
+        @draft = false
+        @refids = Set.new
+        @anchors = {}
+      end
+
       def document(node)
-        result = ["<?xml version='1.0' encoding='UTF-8'?>\n<iso-standard#{document_ns_attributes node}>"]
-        $draft = node.attributes.has_key?("draft")
+        init
+        ret1 = makexml(node)
+        validate(ret1)
+        ret = ret1.to_xml(indent: 2)
+        filename = node.attr("docfile").gsub(/\.adoc/, ".xml").
+          gsub(%r{^.*/}, '')
+        File.open("#{filename}", "w") { |f| f.write(ret) }
+        doc_converter.convert filename
+        ret
+      end
+
+      def makexml(node)
+        result = ["<?xml version='1.0' encoding='UTF-8'?>\n<iso-standard>"]
+        @draft = node.attributes.has_key?("draft")
         result << noko { |ixml| front node, ixml }
         result << noko { |ixml| middle node, ixml }
         result << "</iso-standard>"
-        ret = result.flatten * "\n"
-        ret1 = cleanup(Nokogiri::XML(ret))
-        Validate::validate(ret1)
-        ret1.to_xml(indent: 2)
+        result = textcleanup(result.flatten * "\n")
+        ret1 = cleanup(Nokogiri::XML(result))
+        ret1.root.add_namespace(nil, "http://riboseinc.com/isoxml")
+        ret1
+      end
+
+      def is_draft
+        @draft
       end
 
       def front(node, xml)
-        xml.front do |xml_front|
-          title node, xml_front
-          metadata node, xml_front
-        end
+        title node, xml
+        metadata node, xml
       end
 
       def middle(node, xml)
-        xml.middle do |xml_middle|
-          xml_middle << node.content if node.blocks?
+        xml.sections do |s|
+          s << node.content if node.blocks?
         end
       end
 
-      def termsource(node)
-        result = []
-        result << noko do |xml|
-          xml.termref do |xml_t|
-            matched = /^(?<xref><xref[^>]+>)
-            (,\s(?<section>.[^, ]+))?
-              (,\s(?<text>.*))?$/x.match node.content
-            if matched.nil?
-              warn %(asciidoctor: WARNING (#{current_location(node)}): term reference not in expected format: #{node.content})
-            else
-              seen_xref = Nokogiri::XML.fragment(matched[:xref])
-              attr = {
-                target: seen_xref.children[0]["target"], 
-                format: seen_xref.children[0]["format"],
-              }
-              xml_t.xref seen_xref.children[0].content, **attr_code(attr)
-              xml_t.isosection matched[:section] if matched[:section]
-              xml_t.modification { |m| m << matched[:text] } if matched[:text]
-            end
+      def add_term_source(xml_t, seen_xref, m)
+        attr = { bibitemid: seen_xref.children[0]["target"],
+                 format: seen_xref.children[0]["format"] }
+        xml_t.origin seen_xref.children[0].content, **attr_code(attr)
+        xml_t.isosection m[:section].gsub(/ /, "")  if m[:section]
+        if m[:text]
+          xml_t.modification do |mod| 
+            mod.p { |p| p << m[:text]  }
           end
         end
-        result
+      end
+
+      TERM_REFERENCE_RE_STR = <<~REGEXP
+             ^(?<xref><xref[^>]+>)
+               (,\s(?<section>[^, ]+))?
+               (,\s(?<text>.*))?
+             $
+      REGEXP
+      TERM_REFERENCE_RE =
+        Regexp.new(TERM_REFERENCE_RE_STR.gsub(/\s/, "").gsub(/_/, "\\s"),
+                   Regexp::IGNORECASE)
+
+
+      def extract_termsource_refs(text)
+        matched = TERM_REFERENCE_RE.match text
+        if matched.nil?
+          warning(node, "term reference not in expected format", text)
+        end
+        matched
+      end
+
+      def termsource(node)
+        matched = extract_termsource_refs(node.content) or return
+        noko do |xml|
+          attrs = { status: matched[:text] ? "identical" : "modified" }
+          xml.termsource **attrs do |xml_t|
+            seen_xref = Nokogiri::XML.fragment(matched[:xref])
+            add_term_source(xml_t, seen_xref, matched)
+            style(node, matched[:text])
+          end
+        end.join("\n")
       end
 
       def paragraph(node)
         return termsource(node) if node.role == "source"
-        result = []
-        result << noko do |xml|
-          xml.p do |xml_t|
+        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
+            style(node, Utils::flatten_rawtext(node).join(" "))
           end
-        end
-        result
+        end.join("\n")
       end
 
       def inline_footnote(node)
         noko do |xml|
-          xml.fn do |xml_t|
-            xml_t << node.text
+          @fn_number += 1
+          xml.fn **{reference: @fn_number} do |fn|
+            # TODO multi-paragraph footnotes
+            fn.p { |p| p << node.text }
+            footnote_style(node, node.text)
           end
-        end.join
+        end.join("\n")
       end
 
       def open(node)
@@ -106,14 +170,21 @@ module Asciidoctor
         noko do |xml|
           xml << node.text
           xml.br
-        end.join
+        end.join("\n")
       end
 
       def page_break(node)
         noko do |xml|
           xml << node.text
           xml.pagebreak
-        end.join
+        end.join("\n")
+      end
+
+      def thematic_break(node)
+        noko do |xml|
+          xml << node.text
+          xml.hr
+        end.join("\n")
       end
 
       def inline_quoted(node)
@@ -126,14 +197,14 @@ module Asciidoctor
           when :single then xml << "'#{node.text}'"
           when :superscript then xml.sup node.text
           when :subscript then xml.sub node.text
-          when :asciimath then xml.stem node.text
+          when :asciimath then xml.stem node.text, **{ type: "AsciiMath" }
           else
-            if node.role == "alt"
-              xml.admitted_term { |a| a << node.text }
-            elsif node.role == "deprecated"
-              xml.deprecated_term { |a| a << node.text }
-            elsif node.role == "domain"
-              xml.termdomain { |a| a << node.text }
+            case node.role
+            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

data/lib/asciidoctor/iso/blocks.rb

@@ -4,165 +4,172 @@ require "uri"
 module Asciidoctor
   module ISO
     module Blocks
+      def id_attr(node = nil)
+        { id: Utils::anchor_or_uuid(node) }
+      end
+
       def stem(node)
-        stem_attributes = {
-          anchor: node.id,
-        }
         # NOTE: html escaping is performed by Nokogiri
         stem_content = node.lines.join("\n")
 
         noko do |xml|
-          xml.formula **attr_code(stem_attributes) do |s|
-            s.stem stem_content
+          xml.formula **id_attr(node) do |s|
+            s.stem stem_content, **{ type: "AsciiMath" }
+            style(node, stem_content)
           end
         end
       end
 
+      def sidebar_attrs(node)
+        date = node.attr("date") || DateTime.now.iso8601.gsub(/\+.*$/, "")
+        date += "T0000" unless /T/.match? date
+        { 
+          reviewer: node.attr("reviewer") || node.attr("source") || "(Unknown)",
+          id: Utils::anchor_or_uuid(node),
+          date: date.gsub(/[:-]/, ""),
+        }
+      end
+
       def sidebar(node)
-        if $draft
-          note_attributes = {
-            color: node.attr("color") ? node.attr("color") : "red",
-          }
-          content = flatten_rawtext(node.content).join("\n")
-          noko do |xml|
-            xml.review_note content, **attr_code(note_attributes)
+        return unless is_draft
+        content = Utils::flatten_rawtext(node.content).join("\n")
+        noko do |xml| 
+          xml.review **attr_code(sidebar_attrs(node)) do |r|
+            r << content
           end
         end
       end
 
-      def termnote(node)
-        note_attributes = { anchor: node.id }
-
-        warn <<~WARNING_MESSAGE if node.blocks?
-          asciidoctor: WARNING (#{current_location(node)}): \
-          comment can not contain blocks of text in XML RFC:\n #{node.content}
-        WARNING_MESSAGE
+      def termnote(n)
+        noko do |xml|
+          xml.termnote **id_attr(n) do |ex|
+            if n.blocks? then ex << n.content
+            else 
+              ex.p {|p| p << n.content }
+            end
+            style(n, Utils::flatten_rawtext(n.content).join("\n"))
+          end
+        end.join("\n")
+      end
 
+      def note(n)
         noko do |xml|
-          xml.termnote **attr_code(note_attributes) do |xml_cref|
-            xml_cref << node.content
+          xml.note **id_attr(n) do |c|
+            if n.blocks? then c << n.content
+            else
+              c.p { |p| p << n.content }
+            end
+            text = Utils::flatten_rawtext(n.content).join("\n")
+            note_style(n, text)
           end
-        end.join
+        end.join("\n")
+      end
+
+      def admonition_attrs(node)
+        name = node.attr("name")
+        type = node.attr("type") and
+          ["danger", "safety precautions"].each do |t|
+          name = t if type.casecmp(t).zero?
+        end
+        { id: Utils::anchor_or_uuid(node), type: name }
       end
 
       def admonition(node)
-        return termnote(node) if $term_def
+        return termnote(node) if in_terms
+        return note(node) if node.attr("name") == "note"
         noko do |xml|
-          xml.note **attr_code(anchor: node.id) do |xml_cref|
-            if node.blocks?
-              xml_cref << node.content
+          xml.admonition **admonition_attrs(node) do |a|
+            if node.blocks? then a << node.content
             else
-              xml_cref.p { |p| p << node.content }
+              a.p { |p| p << node.content }
             end
           end
-        end.join
+        end.join("\n")
       end
 
       def term_example(node)
         noko do |xml|
-          xml.termexample **attr_code(anchor: node.id) do |ex|
-            ex << node.content
+          xml.termexample **id_attr(node) do |ex|
+            c = node.content
+            if node.blocks? then ex << c 
+            else 
+              ex.p {|p| p << c }
+            end
+            text = Utils::flatten_rawtext(c).join("\n")
+            termexample_style(node, text)
           end
-        end.join
+        end.join("\n")
       end
 
       def example(node)
-        return term_example(node) if $term_def
+        return term_example(node) if in_terms
         noko do |xml|
-          xml.example **attr_code(anchor: node.id) do |ex|
-            ex << node.content
+          xml.example **id_attr(node) do |ex|
+            content = node.content
+            ex << content
+            text = Utils::flatten_rawtext(content).join("\n")
+            termexample_style(node, text)
           end
-        end.join
+        end.join("\n")
       end
 
       def preamble(node)
-        result = []
-        result << noko do |xml|
-          xml.foreword do |xml_abstract|
-            xml_abstract << node.content
+        noko do |xml|
+          xml.content do |xml_abstract|
+            xml_abstract.title { |t| t << "Foreword" }
+            content = node.content
+            xml_abstract << content
+            text = Utils::flatten_rawtext(content).join("\n")
+            foreword_style(node, text)
           end
-        end
-        result
+        end.join("\n")
       end
 
-      def section(node)
-        attr = { anchor: node.id.empty? ? nil : node.id }
+      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"),
+          width: node.attr("width") }
+      end
+
+      def image(node)
         noko do |xml|
-          case node.title.downcase
-          when "introduction"
-            xml.introduction **attr_code(attr) do |xml_section|
-              xml_section << node.content
-            end
-          when "patent notice"
-            xml.patent_notice **attr_code(attr) do |xml_section|
-              xml_section << node.content
-            end
-          when "scope"
-            xml.scope **attr_code(attr) do |xml_section|
-              xml_section << node.content
-            end
-          when "normative references"
-            $norm_ref = true
-            xml.norm_ref **attr_code(attr) do |xml_section|
-              xml_section << node.content
-            end
-            $norm_ref = false
-          when "terms and definitions"
-            $term_def = true
-            xml.terms_defs **attr_code(attr) do |xml_section|
-              xml_section << node.content
-            end
-            $term_def = false
-          when "bibliography"
-            $biblio = true
-            xml.bibliography **attr_code(attr) do |xml_section|
-              xml_section << node.content
-            end
-            $biblio = true
-          else
-            if $term_def
-              xml.termdef **attr_code(attr) do |xml_section|
-                xml_section.term { |name| name << node.title }
-                xml_section << node.content
-              end
-            elsif node.attr("style") == "appendix"
-              xml.annex **attr_code(attr) do |xml_section|
-                xml_section.name { |name| name << node.title }
-                xml_section << node.content
-              end
-            else
-              xml.clause **attr_code(attr) do |xml_section|
-                unless node.title.nil?
-                  xml_section.name { |name| name << node.title }
-                end
-                xml_section << node.content
-              end
-            end
+          xml.figure **id_attr(node) do |f|
+            f.name { |name| name << node.title } unless node.title.nil?
+            f.image **attr_code(image_attributes(node))
           end
-        end.join
+        end
       end
 
-      def image(node)
-        uri = node.image_uri node.attr("target")
-        artwork_attributes = {
-          anchor: node.id,
-          src: uri,
+      def quote_attrs(node)
+        { 
+          id: Utils::anchor_or_uuid(node), 
+          align: node.attr("align"),
         }
+      end
 
-        noko do |xml|
-          xml.figure **attr_code(artwork_attributes) do |f|
-            f.name { |name| name << node.title } unless node.title.nil?
+      def quote_attribution(node, out)
+        if node.attr("attribution")
+          out.fullname do |f|
+            f.surname { |s| s << node.attr("attribution") }
+            # TODO: will break up into name components
           end
         end
+        if node.attr("citetitle")
+          # TODO: eref
+        end
       end
 
       def quote(node)
         noko do |xml|
-          xml.quote **attr_code(anchor: node.id) do |xml_blockquote|
-            if node.blocks?
-              xml_blockquote << node.content
+          xml.quote **attr_code(quote_attrs(node)) do |q|
+            quote_attribution(node, out)
+            if node.blocks? then q << node.content
             else
-              xml_blockquote.p { |p| p << node.content }
+              q.p { |p| p << node.content }
             end
           end
         end
@@ -173,10 +180,14 @@ module Asciidoctor
         noko do |xml|
           if node.parent.context != :example
             xml.figure do |xml_figure|
-              xml_figure.sourcecode { |s| s << node.content }
+              xml_figure.sourcecode **id_attr(node) do |s| 
+                s << node.content 
+              end
             end
           else
-            xml.sourcecode { |s| s << node.content }
+            xml.sourcecode **id_attr(node) do |s|
+              s << node.content 
+            end
           end
         end
       end