metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/word_function/comments.rb

@@ -0,0 +1,145 @@
+module IsoDoc::WordFunction
+  module Comments
+
+    def in_comment
+      @in_comment
+    end
+
+    def comments(div)
+      return if @comments.empty?
+      div.div **{ style: "mso-element:comment-list" } do |div1|
+        @comments.each { |fn| div1.parent << fn }
+      end
+    end
+
+    def review_note_parse(node, out)
+      fn = @comments.length + 1
+      make_comment_link(out, fn, node)
+      @in_comment = true
+      @comments << make_comment_text(node, fn)
+      @in_comment = false
+    end
+
+    def comment_link_attrs(fn, node)
+      { style: "MsoCommentReference", target: fn,
+        class: "commentLink", from: node["from"],
+        to: node["to"] }
+    end
+
+    # add in from and to links to move the comment into place
+    def make_comment_link(out, fn, node)
+      out.span(**comment_link_attrs(fn, node)) 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:#{node['date'].gsub(/[:-]+/, '')}" }
+          s2.span **{ style: "mso-special-character:comment",
+                      target: fn } # do |s|
+        end
+      end
+    end
+
+    def make_comment_target(out)
+      out.span **{ style: "MsoCommentReference" } do |s1|
+        s1.span **{ lang: "EN-GB", style: "font-size:9.0pt" } do |s2|
+          s2.span **{ style: "mso-special-character:comment" }
+        end
+      end
+    end
+
+    def make_comment_text(node, fn)
+      noko do |xml|
+        xml.div **{ style: "mso-element:comment", id: fn } do |div|
+          div.span **{ style: %{mso-comment-author:"#{node['reviewer']}"} }
+          make_comment_target(div)
+          node.children.each { |n| parse(n, div) }
+        end
+      end.join("\n")
+    end
+
+    def comment_cleanup(docxml)
+      move_comment_link_to_from(docxml)
+      reorder_comments_by_comment_link(docxml)
+      embed_comment_in_comment_list(docxml)
+    end
+
+    COMMENT_IN_COMMENT_LIST1 =
+      '//div[@style="mso-element:comment-list"]//'\
+      'span[@style="MsoCommentReference"]'.freeze
+
+    def embed_comment_in_comment_list(docxml)
+      #docxml.xpath(COMMENT_IN_COMMENT_LIST).each do |x|
+      docxml.xpath(COMMENT_IN_COMMENT_LIST1).each do |x|
+        n = x.next_element
+        n&.children&.first&.add_previous_sibling(x.remove)
+      end
+      docxml
+    end
+
+    def move_comment_link_to_from1(x, fromlink)
+      x.remove
+      link = x.at(".//a")
+      fromlink.replace(x)
+      link.children = fromlink
+    end
+
+    def comment_attributes(docxml, x)
+      fromlink = docxml.at("//*[@id='#{x['from']}']")
+      return(nil) if fromlink.nil?
+      tolink = docxml.at("//*[@id='#{x['to']}']") || fromlink
+      target = docxml.at("//*[@id='#{x['target']}']")
+      { from: fromlink, to: tolink, target: target }
+    end
+
+    def wrap_comment_cont(from, target)
+      s = from.replace("<span style='mso-comment-continuation:#{target}'>")
+      s.first.children = from
+    end
+
+    def skip_comment_wrap(from)
+      from["style"] != "mso-special-character:comment"
+    end
+
+    def insert_comment_cont(from, to, target)
+      # includes_to = from.at(".//*[@id='#{to}']")
+      while !from.nil? && from["id"] != to
+        following = from.xpath("./following::*")
+        (from = following.shift) && incl_to = from.at(".//*[@id='#{to}']")
+        while !incl_to.nil? && !from.nil? && skip_comment_wrap(from)
+          (from = following.shift) && incl_to = from.at(".//*[@id='#{to}']")
+        end
+        wrap_comment_cont(from, target) if !from.nil?
+      end
+    end
+
+    def move_comment_link_to_from(docxml)
+      docxml.xpath('//span[@style="MsoCommentReference"][@from]').each do |x|
+        attrs = comment_attributes(docxml, x) || next
+        move_comment_link_to_from1(x, attrs[:from])
+        insert_comment_cont(attrs[:from], x["to"], x["target"])
+      end
+    end
+
+    def get_comments_from_text(docxml, link_order)
+      comments = []
+      docxml.xpath("//div[@style='mso-element:comment']").each do |c|
+        next unless c["id"] && !link_order[c["id"]].nil?
+        comments << { text: c.remove.to_s, id: c["id"] }
+      end
+      comments.sort! { |a, b| link_order[a[:id]] <=> link_order[b[:id]] }
+      # comments
+    end
+
+    COMMENT_TARGET_XREFS1 =
+      "//span[@style='mso-special-character:comment']/@target".freeze
+
+    def reorder_comments_by_comment_link(docxml)
+      link_order = {}
+      docxml.xpath(COMMENT_TARGET_XREFS1).each_with_index do |target, i|
+        link_order[target.value] = i
+      end
+      comments = get_comments_from_text(docxml, link_order)
+      list = docxml.at("//*[@style='mso-element:comment-list']") || return
+      list.children = comments.map { |c| c[:text] }.join("\n")
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/word_function/footnotes.rb

@@ -0,0 +1,105 @@
+module IsoDoc::WordFunction
+  module Footnotes
+    def bookmarkid
+      ret = "X"
+      until !@bookmarks_allocated[ret] do
+        ret = Random.rand(1000000000)
+      end
+      @bookmarks_allocated[ret] = true
+      sprintf "%09d", ret
+    end
+
+    def footnotes(div)
+      return if @footnotes.empty?
+      @footnotes.each { |fn| div.parent << fn }
+    end
+
+    def make_table_footnote_link(out, fnid, fnref)
+      attrs = { href: "##{fnid}", class: "TableFootnoteRef" }
+      out.a **attrs do |a|
+        a << fnref
+      end
+    end
+
+    def make_table_footnote_target(out, fnid, fnref)
+      attrs = { id: fnid, class: "TableFootnoteRef" }
+      out.span do |s|
+        out.span **attrs do |a|
+          a << fnref
+        end
+        insert_tab(s, 1)
+      end
+    end
+
+    def make_table_footnote_text(node, fnid, fnref)
+      attrs = { id: "ftn#{fnid}" }
+      noko do |xml|
+        xml.div **attr_code(attrs) do |div|
+          make_table_footnote_target(div, fnid, fnref)
+          node.children.each { |n| parse(n, div) }
+        end
+      end.join("\n")
+    end
+
+    def make_generic_footnote_text(node, fnid)
+      noko do |xml|
+        xml.aside **{ id: "ftn#{fnid}" } do |div|
+          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"] || UUIDTools::UUID.random_create.to_s
+      tid = get_table_ancestor_id(node)
+      make_table_footnote_link(out, tid + fn, fn)
+      # 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_table_footnote_text(node, tid + fn, fn) }
+      @in_footnote = false
+      @seen_footnote << (tid + fn)
+    end
+
+    def seen_footnote_parse(node, out, fn)
+      out.span **{style: "mso-element:field-begin"}
+      out << " NOTEREF _Ref#{@fn_bookmarks[fn]} \\f \\h"
+      out.span **{style: "mso-element:field-separator"}
+      out.span **{class: "MsoFootnoteReference"} do |s|
+        s << fn
+      end
+      out.span **{style: "mso-element:field-end"}
+    end
+
+    def footnote_parse(node, out)
+      return table_footnote_parse(node, out) if (@in_table || @in_figure) &&
+        !node.ancestors.map {|m| m.name }.include?("name")
+      fn = node["reference"] || UUIDTools::UUID.random_create.to_s
+      return seen_footnote_parse(node, out, fn) if @seen_footnote.include?(fn)
+      @fn_bookmarks[fn] = bookmarkid
+      out.span **{style: "mso-bookmark:_Ref#{@fn_bookmarks[fn]}"} do |s|
+        s.a **{ "class": "FootnoteRef", "epub:type": "footnote", href: "#ftn#{fn}" } do |a|
+          a.sup { |sup| sup << fn }
+        end
+      end
+      @in_footnote = true
+      @footnotes << make_generic_footnote_text(node, fn)
+      @in_footnote = false
+      @seen_footnote << fn
+    end
+
+    def make_footnote(node, fn)
+      return if @seen_footnote.include?(fn)
+      @in_footnote = true
+      @footnotes << make_generic_footnote_text(node, fn)
+      @in_footnote = false
+      @seen_footnote << fn
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/word_function/inline.rb

@@ -0,0 +1,77 @@
+module IsoDoc::WordFunction
+  module Body
+    def section_break(body)
+      body.p do |p|
+        p.br **{ clear: "all", class: "section" }
+      end
+    end
+
+    def page_break(out)
+      out.p do |p|
+        p.br **{ clear: "all",
+                 style: "mso-special-character:line-break;"\
+                 "page-break-before:always" }
+      end
+    end
+
+    def pagebreak_parse(node, out)
+      return page_break(out) if node["orientation"].nil?
+      out.p do |p|
+        p.br **{clear: "all", class: "section",
+                orientation: node["orientation"] }
+      end
+    end
+
+    def imgsrc(node)
+      ret = svg_to_emf(node) and return ret
+      return node["src"] unless %r{^data:image/}.match node["src"]
+      save_dataimage(node["src"])
+    end
+
+    def image_parse(node, out, caption)
+      attrs = { src: imgsrc(node),
+                height: node["height"],
+                alt: node["alt"],
+                title: node["title"],
+                width: node["width"] }
+      out.img **attr_code(attrs)
+      image_title_parse(out, caption)
+    end
+
+    def svg_to_emf_filename(uri)
+      File.join(File.dirname(uri), File.basename(uri, ".*")) + ".emf"
+    end
+
+    def svg_to_emf(node)
+      return unless node["mimetype"] == "image/svg+xml"
+      uri = node["src"]
+      %r{^data:image/}.match(uri) and uri = save_dataimage(uri)
+      ret = svg_to_emf_filename(uri)
+      File.exists?(ret) and return ret
+      exe = inkscape_installed? or return nil
+      system %(#{exe} --export-type="emf" #{uri}) and
+        return ret
+      nil
+    end
+
+    def inkscape_installed?
+      cmd = "inkscape"
+      exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+      ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+        exts.each do |ext|
+          exe = File.join(path, "#{cmd}#{ext}")
+          return exe if File.executable?(exe) && !File.directory?(exe)
+        end
+      end
+      nil
+    end
+
+    def xref_parse(node, out)
+      target = /#/.match(node["target"]) ? node["target"].sub(/#/, ".doc#") :
+        "##{node["target"]}"
+        out.a(**{ "href": target }) do |l|
+          node.children.each { |n| parse(n, l) }
+        end
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/word_function/postprocess.rb

@@ -0,0 +1,247 @@
+require "fileutils"
+require_relative "./postprocess_cover.rb"
+
+module IsoDoc::WordFunction
+  module Postprocess
+    # add namespaces for Word fragments
+    WORD_NOKOHEAD = <<~HERE.freeze
+    <!DOCTYPE html SYSTEM
+    "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+    <html xmlns="http://www.w3.org/1999/xhtml"
+xmlns:v="urn:schemas-microsoft-com:vml"
+xmlns:o="urn:schemas-microsoft-com:office:office"
+xmlns:w="urn:schemas-microsoft-com:office:word"
+xmlns:m="http://schemas.microsoft.com/office/2004/12/omml">
+    <head> <title></title> <meta charset="UTF-8" /> </head>
+    <body> </body> </html>
+    HERE
+
+    def to_word_xhtml_fragment(xml)
+      doc = ::Nokogiri::XML.parse(WORD_NOKOHEAD)
+      fragment = ::Nokogiri::XML::DocumentFragment.new(doc, xml, doc.root)
+      fragment
+    end
+
+    def table_note_cleanup(docxml)
+      super
+      # preempt html2doc putting MsoNormal there
+      docxml.xpath("//p[not(self::*[@class])]"\
+                   "[ancestor::*[@class = 'Note']]").each do |p|
+        p["class"] = "Note"
+      end
+    end
+
+    def postprocess(result, filename, dir)
+      filename = filename.sub(/\.doc$/, "")
+      header = generate_header(filename, dir)
+      result = from_xhtml(cleanup(to_xhtml(textcleanup(result))))
+      toWord(result, filename, dir, header)
+      @files_to_delete.each { |f| FileUtils.rm_f f }
+    end
+
+    def toWord(result, filename, dir, header)
+      result = from_xhtml(word_cleanup(to_xhtml(result)))
+      unless @landscapestyle.empty?
+        @wordstylesheet&.open
+        @wordstylesheet&.write(@landscapestyle)
+        @wordstylesheet&.close
+      end
+      Html2Doc.process(result, filename: filename, stylesheet: @wordstylesheet&.path,
+                       header_file: header&.path, dir: dir,
+                       asciimathdelims: [@openmathdelim, @closemathdelim],
+                       liststyles: { ul: @ulstyle, ol: @olstyle })
+      header&.unlink
+      @wordstylesheet&.unlink
+    end
+
+    def word_admonition_images(docxml)
+      docxml.xpath("//div[@class = 'Admonition']//img").each do |i|
+        i["width"], i["height"] =
+          Html2Doc.image_resize(i, image_localfile(i), @maxheight, 300)
+      end
+    end
+
+    def word_cleanup(docxml)
+      word_annex_cleanup(docxml)
+      word_preface(docxml)
+      word_nested_tables(docxml)
+      word_table_align(docxml)
+      word_table_separator(docxml)
+      word_admonition_images(docxml)
+      word_list_continuations(docxml)
+      word_example_cleanup(docxml)
+      word_pseudocode_cleanup(docxml)
+      word_image_caption(docxml)
+      word_section_breaks(docxml)
+      authority_cleanup(docxml)
+      word_footnote_format(docxml)
+      docxml
+    end
+
+    def word_nested_tables(docxml)
+      docxml.xpath("//table").each do |t|
+        t.xpath(".//table").reverse.each do |tt|
+          t.next = tt.remove
+        end
+      end
+    end
+
+    def authority_cleanup1(docxml, klass)
+      dest = docxml.at("//div[@id = 'boilerplate-#{klass}-destination']")
+      auth = docxml.at("//div[@id = 'boilerplate-#{klass}' or @class = 'boilerplate-#{klass}']")
+      auth&.xpath(".//h1[not(text())] | .//h2[not(text())]")&.each { |h| h.remove }
+      auth&.xpath(".//h1 | .//h2")&.each do |h|
+        h.name = "p"
+        h["class"] = "TitlePageSubhead"
+      end
+      dest and auth and dest.replace(auth.remove)
+    end
+
+    def authority_cleanup(docxml)
+      %w(copyright license legal feedback).each do |t|
+        authority_cleanup1(docxml, t)
+      end
+    end
+
+    def style_update(node, css)
+      return unless node
+      node["style"] = node["style"] ?  node["style"].sub(/;?$/, ";#{css}") : css
+    end
+
+    def word_image_caption(docxml)
+      docxml.xpath("//p[@class = 'FigureTitle' or @class = 'SourceTitle']").
+        each do |t|
+        if t&.previous_element&.name == "img"
+          img = t.previous_element
+          t.previous_element.swap("<p class=\'figure\'>#{img.to_xml}</p>")
+        end
+        style_update(t&.previous_element, "page-break-after:avoid;")
+      end
+    end
+
+    def word_list_continuations(docxml)
+      list_add(docxml.xpath("//ul[not(ancestor::ul) and not(ancestor::ol)]"), 1)
+      list_add(docxml.xpath("//ol[not(ancestor::ul) and not(ancestor::ol)]"), 1)
+    end
+
+    def list_add(xpath, lvl)
+      xpath.each do |list|
+        (list.xpath(".//li") - list.xpath(".//ol//li | .//ul//li")).each do |l|
+          l.xpath("./p | ./div").each_with_index do |p, i|
+            next if i == 0
+            p.wrap(%{<div class="ListContLevel#{lvl}"/>})
+          end
+          list_add(l.xpath(".//ul") - l.xpath(".//ul//ul | .//ol//ul"), lvl + 1)
+          list_add(l.xpath(".//ol") - l.xpath(".//ul//ol | .//ol//ol"), lvl + 1)
+        end
+      end
+    end
+
+    def word_table_align(docxml)
+      docxml.xpath("//td[@align]/p | //th[@align]/p").each do |p|
+        next if p["align"]
+        style_update(p, "text-align: #{p.parent["align"]}")
+      end
+    end
+
+=begin
+    EMPTY_PARA = "<p style='margin-top:0cm;margin-right:0cm;"\
+      "margin-bottom:0cm;margin-left:0.0pt;margin-bottom:.0001pt;"\
+      "line-height:1.0pt;mso-line-height-rule:exactly'>"\
+      "<span lang=EN-GB style='display:none;mso-hide:all'>&nbsp;</span></p>"
+
+    def table_after_table(docxml)
+     docxml.xpath("//table[following-sibling::*[1]/self::table]").each do |t|
+        t.add_next_sibling(EMPTY_PARA)
+      end
+    end
+=end
+
+    def word_table_separator(docxml)
+      docxml.xpath("//p[@class = 'TableTitle']").each do |t|
+        next unless t.children.empty?
+        t["style"] = t["style"].sub(/;?$/, ";font-size:0pt;")
+        t.children = "&nbsp;"
+      end
+    end
+
+    def word_annex_cleanup(docxml)
+    end
+
+    def word_example_cleanup(docxml)
+      docxml.xpath("//div[@class = 'example']//p[not(@class)]").each do |p|
+        p["class"] = "example"
+      end
+    end
+
+    def word_pseudocode_cleanup(docxml)
+      docxml.xpath("//div[@class = 'pseudocode']//p[not(@class)]").each do |p|
+        p["class"] = "pseudocode"
+      end
+    end
+
+    def generate_header(filename, _dir)
+      return nil unless @header
+      template = IsoDoc::Common.liquid(File.read(@header, encoding: "UTF-8"))
+      meta = @meta.get
+      meta[:filename] = filename
+      params = meta.map { |k, v| [k.to_s, v] }.to_h
+      Tempfile.open(%w(header html), :encoding => "utf-8") do |f|
+        f.write(template.render(params))
+        f
+      end
+    end
+
+    def word_section_breaks(docxml)
+      @landscapestyle = ""
+      word_section_breaks1(docxml, "WordSection2")
+      word_section_breaks1(docxml, "WordSection3")
+      word_remove_pb_before_annex(docxml)
+      docxml.xpath("//br[@orientation]").each { |br| br.delete("orientation") }
+    end
+
+    def word_section_breaks1(docxml, sect)
+      docxml.xpath("//div[@class = '#{sect}']//br[@orientation]").reverse.
+        each_with_index do |br, i|
+        @landscapestyle += "\ndiv.#{sect}_#{i} {page:#{sect}"\
+          "#{br["orientation"] == "landscape" ? "L" : "P"};}\n"
+        split_at_section_break(docxml, sect, br, i)
+      end
+    end
+
+    def split_at_section_break(docxml, sect, br, i)
+      move = br.parent.xpath("following::node()") &
+        br.document.xpath("//div[@class = '#{sect}']//*")
+      ins = docxml.at("//div[@class = '#{sect}']").
+        after("<div class='#{sect}_#{i}'/>").next_element
+      move.each do |m|
+        next if m.at("./ancestor::div[@class = '#{sect}_#{i}']")
+        ins << m.remove
+      end
+    end
+
+    # applies for <div class="WordSectionN_M"><p><pagebreak/></p>...
+    def word_remove_pb_before_annex(docxml)
+      docxml.xpath("//div[p/br]").each do |d|
+        /^WordSection\d+_\d+$/.match(d["class"]) or next
+        d.elements[0].name == "p" && !d.elements[0].elements.empty? or next
+        d.elements[0].elements[0].name == "br" && d.elements[0].elements[0]["style"] ==
+          "mso-special-character:line-break;page-break-before:always" or next
+        d.elements[0].remove
+      end
+    end
+
+    def word_footnote_format(docxml)
+      # the content is in a[@epub:type = 'footnote']//sup, but in Word, 
+      # we need to inject content around the autonumbered footnote reference
+      docxml.xpath("//a[@epub:type = 'footnote']").each do |x|
+        footnote_reference_format(x)
+      end
+      docxml.xpath("//a[@class = 'TableFootnoteRef'] | "\
+                   "//span[@class = 'TableFootnoteRef']").each do |x|
+        table_footnote_reference_format(x)
+      end
+      docxml
+    end
+  end
+end