metanorma-cli 1.3.3.1 → 1.3.4

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

@@ -0,0 +1,131 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def prefix_container(container, linkend, _target)
+      l10n(@xrefs.anchor(container, :xref) + ", " + linkend)
+    end
+
+    def anchor_linkend(node, linkend)
+      if node["citeas"].nil? && node["bibitemid"]
+        return @xrefs.anchor(node["bibitemid"] ,:xref) || "???"
+      elsif node["target"] && !/.#./.match(node["target"])
+        linkend = @xrefs.anchor(node["target"], :xref)
+        container = @xrefs.anchor(node["target"], :container, false)
+        (container && get_note_container_id(node) != container &&
+         @xrefs.get[node["target"]]) &&
+        linkend = prefix_container(container, linkend, node["target"])
+        linkend = capitalise_xref(node, linkend)
+      end
+      linkend || "???"
+    end
+
+    def capitalise_xref(node, linkend)
+      return linkend unless %w(Latn Cyrl Grek).include? @script
+      return linkend&.capitalize if node["case"] == "capital"
+      return linkend&.downcase if node["case"] == "lowercase"
+      return linkend if linkend[0,1].match(/\p{Upper}/)
+      prec = nearest_block_parent(node).xpath("./descendant-or-self::text()") &
+        node.xpath("./preceding::text()")
+      (prec.empty? || /(?!<[^.].)\.\s+$/.match(prec.map { |p| p.text }.join)) ?
+        linkend&.capitalize : linkend
+    end
+
+    def nearest_block_parent(node)
+      until %w(p title td th name formula 
+        li dt dd sourcecode pre).include?(node.name)
+        node = node.parent
+      end
+      node
+    end
+
+    def non_locality_elems(node)
+      node.children.select do |c|
+        !%w{locality localityStack}.include? c.name
+      end
+    end
+
+    def get_linkend(node)
+      contents = non_locality_elems(node).select { |c| !c.text? || /\S/.match(c) }
+      return unless contents.empty?
+      link = anchor_linkend(node, docid_l10n(node["target"] || node["citeas"]))
+      link += eref_localities(node.xpath(ns("./locality | ./localityStack")), link)
+      non_locality_elems(node).each { |n| n.remove }
+      node.add_child(link)
+    end
+    # so not <origin bibitemid="ISO7301" citeas="ISO 7301">
+    # <locality type="section"><reference>3.1</reference></locality></origin>
+
+    def eref_localities(refs, target)
+      ret = ""
+      refs.each_with_index do |r, i|
+        delim = ","
+        delim = ";" if r.name == "localityStack" && i>0
+        if r.name == "localityStack"
+          r.elements.each_with_index do |rr, j|
+            ret += eref_localities0(rr, j, target, delim)
+            delim = ","
+          end
+        else
+          ret += eref_localities0(r, i, target, delim)
+        end
+      end
+      ret
+    end
+
+    def eref_localities0(r, i, target, delim)
+      if r["type"] == "whole" then l10n("#{delim} #{@i18n.wholeoftext}")
+      else
+        eref_localities1(target, r["type"], r.at(ns("./referenceFrom")),
+                         r.at(ns("./referenceTo")), delim, @lang)
+      end
+    end
+
+     # TODO: move to localization file
+    def eref_localities1_zh(target, type, from, to, delim)
+      ret = "#{delim} 第#{from.text}" if from
+      ret += "&ndash;#{to.text}" if to
+      loc = (@i18n.locality[type] || type.sub(/^locality:/, "").capitalize )
+      ret += " #{loc}"
+      ret
+    end
+
+    # TODO: move to localization file
+    def eref_localities1(target, type, from, to, delim, lang = "en")
+      return "" if type == "anchor"
+      return l10n(eref_localities1_zh(target, type, from, to, delim)) if lang == "zh"
+      ret = delim
+      loc = @i18n.locality[type] || type.sub(/^locality:/, "").capitalize
+      ret += " #{loc}"
+      ret += " #{from.text}" if from
+      ret += "&ndash;#{to.text}" if to
+      l10n(ret)
+    end
+
+    def xref(docxml)
+      docxml.xpath(ns("//xref")).each do |f|
+        xref1(f)
+      end
+    end
+
+    def eref(docxml)
+      docxml.xpath(ns("//eref")).each do |f|
+        xref1(f)
+      end
+    end
+
+    def origin(docxml)
+      docxml.xpath(ns("//origin[not(termref)]")).each do |f|
+        xref1(f)
+      end
+    end
+
+    def quotesource(docxml)
+      docxml.xpath(ns("//quote/source")).each do |f|
+        xref1(f)
+      end
+    end
+
+    def xref1(f)
+      get_linkend(f)
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/presentation_function/section.rb

@@ -0,0 +1,46 @@
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def clause(docxml)
+      docxml.xpath(ns("//clause | "\
+                      "//terms | //definitions | //references")).
+                     each do |f|
+        clause1(f)
+      end
+    end
+
+    def clause1(f)
+      level = @xrefs.anchor(f['id'], :level, false) || "1"
+      t = f.at(ns("./title")) and t["depth"] = level
+      return if !f.ancestors("boilerplate").empty?
+      return if @suppressheadingnumbers || f["unnumbered"]
+      lbl = @xrefs.anchor(f['id'], :label,
+                          f.parent.name != "sections") or return
+      prefix_name(f, "<tab/>", "#{lbl}#{clausedelim}", "title")
+    end
+
+    def annex(docxml)
+      docxml.xpath(ns("//annex")).each do |f|
+        annex1(f)
+      end
+    end
+
+    def annex1(f)
+      lbl = @xrefs.anchor(f['id'], :label)
+      if t = f.at(ns("./title"))
+        t.children = "<strong>#{t.children.to_xml}</strong>"
+      end
+      prefix_name(f, "<br/><br/>", lbl, "title")
+    end
+
+    def term(docxml)
+      docxml.xpath(ns("//term")).each do |f|
+        term1(f)
+      end
+    end
+
+    def term1(f)
+      lbl = @xrefs.get[f["id"]][:label] or return
+      prefix_name(f, "", "#{lbl}#{clausedelim}", "name")
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/presentation_xml_convert.rb

@@ -0,0 +1,62 @@
+require_relative "presentation_function/block"
+require_relative "presentation_function/inline"
+require_relative "presentation_function/section"
+
+module IsoDoc
+  class PresentationXMLConvert < ::IsoDoc::Convert
+    def initialize(options)
+      @format = :presentation
+      @suffix = "presentation.xml"
+      super
+    end
+
+    def convert1(docxml, filename, dir)
+      @xrefs.parse docxml
+      info docxml, nil
+      conversions(docxml)
+      docxml.to_xml
+    end
+
+    def conversions(docxml)
+      section docxml
+      block docxml
+      inline docxml
+    end
+
+    def section(docxml)
+      clause docxml
+      annex docxml
+      term docxml
+    end
+
+    def block(docxml)
+      table docxml
+      figure docxml
+      sourcecode docxml
+      formula docxml
+      example docxml
+      termexample docxml
+      note docxml
+      termnote docxml
+      permission docxml
+      requirement docxml
+      recommendation docxml
+    end
+
+    def inline(docxml)
+      xref docxml
+      eref docxml
+      origin docxml
+      quotesource docxml
+    end
+
+    def postprocess(result, filename, dir)
+      toXML(result, filename)
+      @files_to_delete.each { |f| FileUtils.rm_rf f }
+    end
+
+    def toXML(result, filename)
+      File.open(filename, "w:UTF-8") { |f| f.write(result) }
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/sassc_importer.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require 'sassc'
+
+class SasscImporter < SassC::Importer
+  def imports(path, _parent_path)
+    unless path.match?(/(css|scss)$/)
+      Import.new("#{path}.scss")
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/version.rb

@@ -0,0 +1,3 @@
+module IsoDoc
+  VERSION = "1.2.1".freeze
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/word_convert.rb

@@ -0,0 +1,45 @@
+require_relative "word_function/comments.rb"
+require_relative "word_function/footnotes.rb"
+require_relative "word_function/body.rb"
+require_relative "word_function/postprocess.rb"
+
+module IsoDoc
+
+=begin
+  module WordConvertModule
+    # http://tech.tulentsev.com/2012/02/ruby-how-to-override-class-method-with-a-module/
+    # https://www.ruby-forum.com/topic/148303
+    #
+    # The following is ugly indeed, but the only way I can split module override methods
+    # across files
+    def self.included base
+      base.class_eval do
+
+        eval File.open(File.join(File.dirname(__FILE__),"wordconvertmodule.rb")).read
+        eval File.open(File.join(File.dirname(__FILE__),"comments.rb")).read
+        eval File.open(File.join(File.dirname(__FILE__),"footnotes.rb")).read
+        eval File.open(File.join(File.dirname(__FILE__),"postprocess.rb")).read
+      end
+    end
+  end
+=end
+
+  class WordConvert < ::IsoDoc::Convert
+    include WordFunction::Comments
+    include WordFunction::Footnotes
+    include WordFunction::Body
+    include WordFunction::Postprocess
+
+    def initialize(options)
+      @format = :doc
+      @suffix = "doc"
+      super
+    end
+
+    def convert(filename, file = nil, debug = false, output_filename = nil)
+      ret = super
+      FileUtils.rm_rf tmpimagedir
+      ret
+    end
+  end
+end

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

@@ -0,0 +1,4 @@
+module IsoDoc
+  module WordFunction
+  end
+end

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

@@ -0,0 +1,214 @@
+require_relative "./table.rb"
+require_relative "./inline.rb"
+
+module IsoDoc::WordFunction
+  module Body
+    def define_head(head, filename, _dir)
+      head.style do |style|
+        loc = File.join(File.dirname(__FILE__), "..", "base_style",
+                        "metanorma_word.scss")
+        stylesheet = File.read(loc, encoding: "utf-8")
+        style.comment "\n#{stylesheet}\n"
+      end
+      super
+    end
+
+    def body_attr
+      { lang: "EN-US", link: "blue", vlink: "#954F72" }
+    end
+
+    def make_body1(body, _docxml)
+      body.div **{ class: "WordSection1" } do |div1|
+        div1.p { |p| p << "&nbsp;" } # placeholder
+      end
+      section_break(body)
+    end
+
+    def make_body2(body, docxml)
+      body.div **{ class: "WordSection2" } do |div2|
+        boilerplate docxml, div2
+        abstract docxml, div2
+        foreword docxml, div2
+        introduction docxml, div2
+        preface docxml, div2
+        acknowledgements docxml, div2
+        div2.p { |p| p << "&nbsp;" } # placeholder
+      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 insert_tab(out, n)
+      out.span **attr_code(style: "mso-tab-count:#{n}") do |span|
+        [1..n].each { span << "&#xA0; " }
+      end
+    end
+
+    def para_class(_node)
+      classtype = nil
+      classtype = "Note" if @note
+      classtype = "MsoCommentText" if in_comment
+      classtype = "Sourcecode" if @annotation
+      classtype
+    end
+
+    def para_parse(node, out)
+      out.p **attr_code(para_attrs(node)) do |p|
+        unless @termdomain.empty?
+          p << "&lt;#{@termdomain}&gt; "
+          @termdomain = ""
+        end
+        node.children.each { |n| parse(n, p) unless n.name == "note" }
+      end
+      node.xpath(ns("./note")).each { |n| parse(n, out) }
+    end
+
+    WORD_DT_ATTRS = {class: @note ? "Note" : nil, align: "left",
+                     style: "margin-left:0pt;text-align:left;"}.freeze
+
+    def dt_parse(dt, term)
+      term.p **attr_code(WORD_DT_ATTRS) do |p|
+        if dt.elements.empty?
+          p << dt.text
+        else
+          dt.children.each { |n| parse(n, p) }
+        end
+      end
+    end
+
+    def dl_parse(node, out)
+      out.table **{ class: "dl" } do |v|
+        node.elements.select { |n| dt_dd? n }.each_slice(2) do |dt, dd|
+          v.tr do |tr|
+            tr.td **{ valign: "top", align: "left" } do |term|
+              dt_parse(dt, term)
+            end
+            tr.td **{ valign: "top" } do |listitem|
+              dd.children.each { |n| parse(n, listitem) }
+            end
+          end
+        end
+        dl_parse_notes(node, v)
+      end
+    end
+
+    def dl_parse_notes(node, v)
+      return if node.elements.reject { |n| dt_dd? n }.empty?
+      v.tr do |tr|
+        tr.td **{ colspan: 2 } do |td|
+          node.elements.reject { |n| dt_dd? n }.each { |n| parse(n, td) }
+        end
+      end
+    end
+
+    def figure_get_or_make_dl(t)
+      dl = t.at(".//table[@class = 'dl']")
+      if dl.nil?
+        t.add_child("<p><b>#{@i18n.key}</b></p><table class='dl'></table>")
+        dl = t.at(".//table[@class = 'dl']")
+      end
+      dl
+    end
+
+    def figure_aside_process(f, aside, key)
+      # get rid of footnote link, it is in diagram
+      f&.at("./a[@class='TableFootnoteRef']")&.remove
+      fnref = f.at(".//span[@class='TableFootnoteRef']/..")
+      tr = key.add_child("<tr></tr>").first
+      dt = tr.add_child("<td valign='top' align='left'></td>").first
+      dd = tr.add_child("<td valign='top'></td>").first
+      fnref.parent = dt
+      aside.xpath(".//p").each do |a|
+        a.delete("class")
+        a.parent = dd
+      end
+    end
+
+    def note_p_parse(node, div)
+      name = node&.at(ns("./name"))&.remove
+      div.p **{ class: "Note" } do |p|
+        p.span **{ class: "note_label" } do |s|
+          name and name.children.each { |n| parse(n, s) }
+        end
+        insert_tab(p, 1)
+        node.first_element_child.children.each { |n| parse(n, p) }
+      end
+      node.element_children[1..-1].each { |n| parse(n, div) }
+    end
+
+    def note_parse1(node, div)
+      name = node&.at(ns("./name"))&.remove
+      div.p **{ class: "Note" } do |p|
+        p.span **{ class: "note_label" } do |s|
+          name and name.children.each { |n| parse(n, s) }
+        end
+        insert_tab(p, 1)
+      end
+      node.children.each { |n| parse(n, div) }
+    end
+
+    def termnote_parse(node, out)
+      name = node&.at(ns("./name"))&.remove
+      out.div **note_attrs(node) do |div|
+        div.p **{ class: "Note" } do |p|
+          if name
+            name.children.each { |n| parse(n, p) }
+            p << l10n(": ")
+          end
+          para_then_remainder(node.first_element_child, node, p, div)
+        end
+      end
+    end
+
+    def para_attrs(node)
+      attrs = { class: para_class(node), id: node["id"], style: "" }
+      unless node["align"].nil?
+        attrs[:align] = node["align"] unless node["align"] == "justify"
+        attrs[:style] += "text-align:#{node['align']};"
+      end
+      attrs[:style] += "#{keep_style(node)}"
+      attrs[:style] = nil if attrs[:style].empty?
+      attrs
+    end
+
+    def example_table_attr(node)
+      super.merge({
+        style: "mso-table-lspace:15.0cm;margin-left:423.0pt;"\
+        "mso-table-rspace:15.0cm;margin-right:423.0pt;"\
+        "mso-table-anchor-horizontal:column;"\
+        "mso-table-overlap:never;border-collapse:collapse;"\
+        "#{keep_style(node)}"
+      })
+    end
+
+    def formula_where(dl, out)
+      return unless dl
+      out.p { |p| p << @i18n.where }
+      parse(dl, out)
+      out.parent.at("./table")["class"] = "formula_dl"
+    end
+
+    def li_parse(node, out)
+      out.li  **attr_code(id: node["id"]) do |li|
+        if node["uncheckedcheckbox"] == "true"
+          li << '<span class="zzMoveToFollowing">&#x2610; </span>'
+        elsif node["checkedcheckbox"] == "true"
+          li << '<span class="zzMoveToFollowing">&#x2611; </span>'
+        end
+        node.children.each { |n| parse(n, li) }
+      end
+    end
+
+    def suffix_url(url)
+      return url if %r{^http[s]?://}.match(url)
+      url.sub(/#{File.extname(url)}$/, ".doc")
+    end
+  end
+end