isodoc 0.0.1

data/lib/isodoc/html.rb

@@ -0,0 +1,44 @@
+module IsoDoc
+  class Convert
+
+    def toHTML(result, filename)
+      result = htmlPreface(htmlstyle(Nokogiri::HTML(result))).to_xml
+      result = populate_template(result)
+      File.open("#{filename}.html", "w") do |f|
+        f.write(result)
+      end
+    end
+
+    def htmlPreface(docxml)
+      cover = Nokogiri::HTML(File.read(@htmlcoverpage, encoding: "UTF-8"))
+      d = docxml.at('//div[@class="WordSection1"]')
+      d.children.first.add_previous_sibling cover.to_xml(encoding: 'US-ASCII')
+      cover = Nokogiri::HTML(File.read(@htmlintropage, encoding: "UTF-8"))
+      d = docxml.at('//div[@class="WordSection2"]')
+      d.children.first.add_previous_sibling cover.to_xml(encoding: 'US-ASCII')
+      body = docxml.at("//*[local-name() = 'body']")
+      body << '<script src="https://cdn.mathjax.org/mathjax/latest/'\
+        'MathJax.js?config=AM_HTMLorMML"></script>'
+      docxml
+    end
+
+    def htmlstylesheet
+      stylesheet = File.read(@htmlstylesheet, encoding: "UTF-8")
+      xml = Nokogiri::XML("<style/>")
+      xml.children.first << Nokogiri::XML::Comment.new(xml, "\n#{stylesheet}\n")
+      xml.root.to_s
+    end
+
+    def htmlstyle(docxml)
+      title = docxml.at("//*[local-name() = 'head']/*[local-name() = 'title']")
+      head = docxml.at("//*[local-name() = 'head']")
+      css = htmlstylesheet
+      if title.nil?
+        head.children.first.add_previous_sibling css
+      else
+        title.add_next_sibling css
+      end
+      docxml
+    end
+  end
+end

data/lib/isodoc/inline.rb

@@ -0,0 +1,211 @@
+require "uuidtools"
+
+module IsoDoc
+  class Convert
+
+    def in_footnote
+      @in_footnote
+    end
+
+    def section_break(body)
+      body.br **{ clear: "all", class: "section" }
+    end
+
+    def page_break(body)
+      body.br **{
+        clear: "all",
+        style: "mso-special-character:line-break;page-break-before:always",
+      }
+    end
+
+    def link_parse(node, out)
+      linktext = node.text
+      linktext = node["target"] if linktext.empty?
+      out.a **{ "href": node["target"] } { |l| l << linktext }
+    end
+
+    def callout_parse(node, out)
+      out << " &lt;#{node.text}&gt;"
+    end
+
+    def get_linkend(node)
+      linkend = node["target"] || node["citeas"]
+      if get_anchors().has_key? node["target"]
+        linkend = get_anchors()[node["target"]][:xref]
+      end
+      if node["citeas"].nil? && get_anchors().has_key?(node["bibitemid"])
+        linkend = get_anchors()[node["bibitemid"]][:xref]
+      end
+      text = node.children.select { |c| c.text? && !c.text.empty? }
+      linkend = text.join(" ") unless text.nil? || text.empty?
+      # so not <origin bibitemid="ISO7301" citeas="ISO 7301">
+      # <locality type="section">3.1</locality></origin>
+      linkend
+    end
+
+    def xref_parse(node, out)
+      linkend = get_linkend(node)
+      out.a **{ "href": node["target"] } { |l| l << linkend }
+    end
+
+    def eref_parse(node, out)
+      linkend = get_linkend(node)
+      section = node.at(ns("./locality"))
+      section.nil? or
+        linkend += ", #{section["type"].capitalize} #{section.text}"
+      if node["type"] == "footnote"
+        out.sup do |s|
+          s.a **{ "href": node["bibitemid"] } { |l| l << linkend }
+        end
+      else
+        out.a **{ "href": node["bibitemid"] } { |l| l << linkend }
+      end
+    end
+
+    def stem_parse(node, out)
+      ooml = if node["type"] == "AsciiMath" then "`#{node.text}`"
+             elsif node["type"] == "MathML" then node.first_element_child.to_s
+             else
+               node.text
+             end
+        out.span **{ class: "stem" } do |span|
+          span.parent.add_child ooml
+        end
+      end
+
+      def pagebreak_parse(node, out)
+        attrs = { clear: all, class: "pagebreak" }
+        out.br **attrs
+      end
+
+      def error_parse(node, out)
+        text = node.to_xml.gsub(/</, "&lt;").gsub(/>/, "&gt;")
+        out.para do |p|
+          p.b **{ role: "strong" } { |e| e << text }
+        end
+      end
+
+      def footnotes(div)
+        return if @footnotes.empty?
+        div.div **{ style: "mso-element:footnote-list" } do |div1|
+          @footnotes.each do |fn|
+            div1.parent << fn
+          end
+        end
+      end
+
+      def footnote_attributes(fn, is_footnote)
+        style = nil
+        style = "mso-footnote-id:ftn#{fn}" if is_footnote
+        { style: style,
+          href: "#_ftn#{fn}",
+          name: "_ftnref#{fn}",
+          title: "",
+          class: "zzFootnote" }
+      end
+
+      def make_footnote_link(a, fnid, fnref, is_footnote)
+        a.span **{ class: "MsoFootnoteReference" } do |s|
+          if is_footnote
+            s.span **{ style: "mso-special-character:footnote" }
+          else
+            s.a **{href: fnid} { a << fnref }
+          end
+        end
+      end
+
+      def make_footnote_target(a, fnid, fnref, is_footnote)
+        a.span **{ class: "MsoFootnoteReference" } do |s|
+          if is_footnote
+            s.span **{ style: "mso-special-character:footnote" }
+          else
+            s.a **{name: fnid} { a << fnref }
+          end
+        end
+      end
+
+      def make_footnote_text(node, fnid, fnref, is_footnote)
+        attrs = { style: "mso-element:footnote", id: "ftn#{fnid}" }
+        attrs[:style] = nil unless is_footnote
+        noko do |xml|
+          xml.div **attr_code(attrs) do |div|
+            div.a **footnote_attributes(fnid, is_footnote) do |a|
+              make_footnote_target(a, fnid, fnref, is_footnote)
+              insert_tab(a, 1) unless is_footnote
+            end
+            node.children.each { |n| parse(n, div) }
+          end
+        end.join("\n")
+      end
+
+      def get_table_ancestor_id(node)
+        table = node.ancestors("table") || node.ancestors("figure")
+        return UUIDTools::UUID.random_create.to_s if table.empty?
+        table.last["id"]
+      end
+
+      def table_footnote_parse(node, out)
+        fn = node["reference"]
+        tid = get_table_ancestor_id(node)
+        out.a **footnote_attributes(tid + fn, false) do |a|
+          make_footnote_link(a, tid + fn, fn, false)
+        end
+        # do not output footnote text if we have already seen it for this table
+        return if @seen_footnote.include?(tid + fn)
+        @in_footnote = true
+        out.aside { |a| a << make_footnote_text(node, tid + fn, fn, false) }
+        @in_footnote = false
+        @seen_footnote << (tid + fn)
+      end
+
+      def footnote_parse(node, out)
+        return table_footnote_parse(node, out) if @in_table || @in_figure
+        fn = node["reference"]
+        out.a **footnote_attributes(fn, true) do |a|
+          make_footnote_link(a, nil, nil, true)
+        end
+        @in_footnote = true
+        @footnotes << make_footnote_text(node, fn, fn, true)
+        @in_footnote = false
+      end
+
+      def comments(div)
+        return if @comments.empty?
+        div.div **{ style: "mso-element:comment-list" } do |div1|
+          @comments.each do |fn|
+            div1.parent << fn
+          end
+        end
+      end
+
+      def make_comment_link(out, fn, date, from)
+        out.span **{ style: "MsoCommentReference" } do |s1|
+          s1.span **{ lang: "EN-GB", style: "font-size:9.0pt"} do |s2|
+            s2.a **{ style: "mso-comment-reference:SMC_#{fn};"\
+                     "mso-comment-date:#{date}" } if from
+            s2.span **{ style: "mso-special-character:comment" } do |s|
+              s << "&nbsp;"
+            end
+          end
+        end
+      end
+
+      def make_comment_text(node, fn)
+        noko do |xml|
+          xml.div **{ style: "mso-element:comment" } do |div|
+            div.span **{ style: %{mso-comment-author:"#{node["reviewer"]}"} }
+            div.p **{ class: "MsoCommentText" } do |p|
+              make_comment_link(p, fn, node["date"], false)
+              node.children.each { |n| parse(n, p) }
+            end
+          end
+        end.join("\n")
+      end
+
+      def review_note_parse(node, out)
+        fn = @comments.length + 1
+        make_comment_link(out, fn, node["date"], true)
+        @comments << make_comment_text(node, fn)
+      end
+  end
+end

data/lib/isodoc/iso2wordhtml.rb

@@ -0,0 +1,143 @@
+require "pp"
+
+module IsoDoc
+  class Convert
+
+    def init_file(filename)
+      filename = filename.gsub(%r{\.[^/.]+$}, "")
+      dir = "#{filename}_files"
+      Dir.mkdir(dir) unless File.exists?(dir)
+      system "rm -r #{dir}/*"
+      [filename, dir]
+    end
+
+    def make_body(xml, docxml)
+      body_attr = { lang: "EN-US", link: "blue", vlink: "#954F72" }
+      xml.body **body_attr do |body|
+        make_body1(body, docxml)
+        make_body2(body, docxml)
+        make_body3(body, docxml)
+      end
+    end
+
+    def make_body1(body, docxml)
+      body.div **{ class: "WordSection1" } do |div1|
+# placeholder
+        div1.p { |p| p << "&nbsp;" }
+      end
+      section_break(body)
+    end
+
+    def make_body2(body, docxml)
+      body.div **{ class: "WordSection2" } do |div2|
+        info docxml, div2
+      end
+      section_break(body)
+    end
+
+    def make_body3(body, docxml)
+      body.div **{ class: "WordSection3" } do |div3|
+        middle docxml, div3
+        footnotes div3
+        comments div3
+      end
+    end
+
+    def info(isoxml, out)
+      # intropage(out)
+      title isoxml, out
+      subtitle isoxml, out
+      id isoxml, out
+      author isoxml, out
+      version isoxml, out
+      foreword isoxml, out
+      introduction isoxml, out
+    end
+
+    def middle_title(out)
+      m = get_metadata
+      out.p **{ class: "zzSTDTitle1" } { |p| p << m[:doctitle] }
+    end
+
+    def middle(isoxml, out)
+      middle_title(out)
+      scope isoxml, out
+      norm_ref isoxml, out
+      terms_defs isoxml, out
+      symbols_abbrevs isoxml, out
+      clause isoxml, out
+      annex isoxml, out
+      bibliography isoxml, out
+    end
+
+    def smallcap_parse(node, xml)
+      xml.span **{style: "font-variant:small-caps;"} do |s|
+        s << node.text
+      end
+    end
+
+    def text_parse(node, out)
+      text = node.text
+      text.gsub!("\n", "<br/>").gsub!(" ", "&nbsp;") if in_sourcecode
+      out << text
+    end
+
+    def parse(node, out)
+      if node.text?
+        text_parse(node, out)
+      else
+        case node.name
+        when "em" then out.i { |e| e << node.text }
+        when "strong" then out.b { |e| e << node.text }
+        when "sup" then out.sup { |e| e << node.text }
+        when "sub" then out.sub { |e| e << node.text }
+        when "tt" then out.tt { |e| e << node.text }
+        when "strike" then out.s { |e| e << node.text }
+        when "smallcap" then smallcap_parse(node, out)
+        when "br" then out.br
+        when "hr" then out.hr
+        when "pagebreak" then pagebreak_parse(node, out)
+        when "callout" then callout_parse(node, out)
+        when "stem" then stem_parse(node, out)
+        when "clause" then clause_parse(node, out)
+        when "subsection" then clause_parse(node, out)
+        when "xref" then xref_parse(node, out)
+        when "eref" then eref_parse(node, out)
+        when "origin" then eref_parse(node, out)
+        when "link" then link_parse(node, out)
+        when "ul" then ul_parse(node, out)
+        when "ol" then ol_parse(node, out)
+        when "li" then li_parse(node, out)
+        when "dl" then dl_parse(node, out)
+        when "fn" then footnote_parse(node, out)
+        when "p" then para_parse(node, out)
+        when "quote" then quote_parse(node, out)
+        when "tr" then tr_parse(node, out)
+        when "note" then note_parse(node, out)
+        when "review" then review_note_parse(node, out)
+        when "admonition" then admonition_parse(node, out)
+        when "formula" then formula_parse(node, out)
+        when "table" then table_parse(node, out)
+        when "figure" then figure_parse(node, out)
+        when "image" then image_parse(node["src"], out, nil)
+        when "sourcecode" then sourcecode_parse(node, out)
+        when "annotation" then annotation_parse(node, out)
+        when "term" then termdef_parse(node, out)
+        when "preferred" then term_parse(node, out)
+        when "admitted" then admitted_term_parse(node, out)
+        when "deprecates" then deprecated_term_parse(node, out)
+        when "domain" then set_termdomain(node.text)
+        when "definition" then definition_parse(node, out)
+        when "termsource" then termref_parse(node, out)
+        when "isosection"
+          out << "[ISOSECTION] #{node.text}"
+        when "modification" then modification_parse(node, out)
+        when "termnote" then termnote_parse(node, out)
+        when "termexample" then termexample_parse(node, out)
+        else
+          error_parse(node, out)
+        end
+      end
+    end
+  end
+end

data/lib/isodoc/lists.rb

@@ -0,0 +1,54 @@
+module IsoDoc
+  class Convert
+    def ul_parse(node, out)
+      out.ul do |ul|
+        node.children.each { |n| parse(n, ul) }
+      end
+    end
+
+    OL_STYLE = {
+      arabic: "1",
+      roman: "i",
+      alphabet: "a",
+      roman_upper: "I",
+      alphabet_upper: "A",
+    }.freeze
+
+    def ol_style(type)
+      OL_STYLE[type.to_sym]
+    end
+
+    def ol_parse(node, out)
+      # attrs = { numeration: node["type"] }
+      style = ol_style(node["type"])
+      out.ol **attr_code(type: style) do |ol|
+        node.children.each { |n| parse(n, ol) }
+      end
+    end
+
+    def li_parse(node, out)
+      out.li do |li|
+        node.children.each { |n| parse(n, li) }
+      end
+    end
+
+    def dl_parse(node, out)
+      out.dl do |v|
+        node.elements.each_slice(2) do |dt, dd|
+          v.dt do |term|
+            if dt.elements.empty?
+              term.p **attr_code(class: is_note ? "Note" : nil) do
+                |p| p << dt.text
+              end
+            else
+              dt.children.each { |n| parse(n, term) }
+            end
+          end
+          v.dd do |listitem|
+            dd.children.each { |n| parse(n, listitem) }
+          end
+        end
+      end
+    end
+  end
+end