metanorma-cli 1.3.3.1 → 1.3.4

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

@@ -0,0 +1,79 @@
+module IsoDoc::WordFunction
+  module Postprocess
+    def word_preface(docxml)
+      word_cover(docxml) if @wordcoverpage
+      word_intro(docxml, @wordToClevels) if @wordintropage
+    end
+
+    def word_cover(docxml)
+      cover = File.read(@wordcoverpage, encoding: "UTF-8")
+      cover = populate_template(cover, :word)
+      coverxml = to_word_xhtml_fragment(cover)
+      docxml.at('//div[@class="WordSection1"]').children.first.previous =
+        coverxml.to_xml(encoding: "US-ASCII")
+    end
+
+    def word_intro(docxml, level)
+      intro = insert_toc(File.read(@wordintropage, encoding: "UTF-8"),
+                         docxml, level)
+      intro = populate_template(intro, :word)
+      introxml = to_word_xhtml_fragment(intro)
+      docxml.at('//div[@class="WordSection2"]').children.first.previous =
+        introxml.to_xml(encoding: "US-ASCII")
+    end
+
+    def insert_toc(intro, docxml, level)
+      intro.sub(/WORDTOC/, make_WordToC(docxml, level))
+    end
+
+    def word_toc_entry(toclevel, heading)
+      bookmark = bookmarkid # Random.rand(1000000000)
+      <<~TOC
+        <p class="MsoToc#{toclevel}"><span class="MsoHyperlink"><span
+        lang="EN-GB" style='mso-no-proof:yes'>
+        <a href="#_Toc#{bookmark}">#{heading}<span lang="EN-GB"
+        class="MsoTocTextSpan">
+        <span style='mso-tab-count:1 dotted'>. </span>
+        </span><span lang="EN-GB" class="MsoTocTextSpan">
+        <span style='mso-element:field-begin'></span></span>
+        <span lang="EN-GB"
+        class="MsoTocTextSpan"> PAGEREF _Toc#{bookmark} \\h </span>
+          <span lang="EN-GB" class="MsoTocTextSpan"><span
+          style='mso-element:field-separator'></span></span><span
+          lang="EN-GB" class="MsoTocTextSpan">1</span>
+          <span lang="EN-GB"
+          class="MsoTocTextSpan"></span><span
+          lang="EN-GB" class="MsoTocTextSpan"><span
+          style='mso-element:field-end'></span></span></a></span></span></p>
+
+      TOC
+    end
+
+    def word_toc_preface(level)
+      <<~TOC.freeze
+      <span lang="EN-GB"><span
+        style='mso-element:field-begin'></span><span
+        style='mso-spacerun:yes'>&#xA0;</span>TOC
+        \\o &quot;1-#{level}&quot; \\h \\z \\u <span
+        style='mso-element:field-separator'></span></span>
+      TOC
+    end
+
+    WORD_TOC_SUFFIX1 = <<~TOC.freeze
+      <p class="MsoToc1"><span lang="EN-GB"><span
+        style='mso-element:field-end'></span></span><span
+        lang="EN-GB"><o:p>&nbsp;</o:p></span></p>
+    TOC
+
+    def make_WordToC(docxml, level)
+      toc = ""
+      #docxml.xpath("//h1 | //h2[not(ancestor::*[@class = 'Section3'])]").
+      xpath = (1..level).each.map { |i| "//h#{i}" }.join (" | ")
+      docxml.xpath(xpath).each do |h|
+        toc += word_toc_entry(h.name[1].to_i, header_strip(h))
+      end
+      toc.sub(/(<p class="MsoToc1">)/,
+              %{\\1#{word_toc_preface(level)}}) +  WORD_TOC_SUFFIX1
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+module IsoDoc::WordFunction
+  module Body
+    def remove_bottom_border(td)
+      td["style"] =
+        td["style"].gsub(/border-bottom:[^;]+;/, "border-bottom:0pt;").
+        gsub(/mso-border-bottom-alt:[^;]+;/, "mso-border-bottom-alt:0pt;")
+    end
+
+    SW1 = "solid windowtext".freeze
+
+    def new_fullcolspan_row(t, tfoot)
+      # how many columns in the table?
+      cols = 0
+      t.at(".//tr").xpath("./td | ./th").each do |td|
+        cols += (td["colspan"] ? td["colspan"].to_i : 1)
+      end
+      style = "border-top:0pt;mso-border-top-alt:0pt;"\
+        "border-bottom:#{SW1} 1.5pt;mso-border-bottom-alt:#{SW1} 1.5pt;"
+      tfoot.add_child("<tr><td colspan='#{cols}' style='#{style}'/></tr>")
+      tfoot.xpath(".//td").last
+    end
+
+    def make_tr_attr(td, row, totalrows, _header)
+      style = td.name == "th" ? "font-weight:bold;" : ""
+      rowmax = td["rowspan"] ? row + td["rowspan"].to_i - 1 : row
+      style += <<~STYLE
+        border-top:#{row.zero? ? "#{SW1} 1.5pt;" : 'none;'}
+        mso-border-top-alt:#{row.zero? ? "#{SW1} 1.5pt;" : 'none;'}
+        border-bottom:#{SW1} #{rowmax == totalrows ? '1.5' : '1.0'}pt;
+        mso-border-bottom-alt:#{SW1} #{rowmax == totalrows ? '1.5' : '1.0'}pt;
+      STYLE
+      { rowspan: td["rowspan"], colspan: td["colspan"],
+        align: td["align"], style: style.gsub(/\n/, "") }
+    end
+
+    def table_attrs(node)
+      super.merge(attr_code({
+        summary: node["summary"],
+        width: node["width"],
+        style: "mso-table-anchor-horizontal:column;"\
+        "mso-table-overlap:never;border-spacing:0;border-width:1px;#{keep_style(node)}"
+      }))
+    end
+
+    def table_parse(node, out)
+      @in_table = true
+      table_title_parse(node, out)
+      out.div **{ align: "center", class: "table_container" } do |div|
+        div.table **table_attrs(node) do |t|
+          thead_parse(node, t)
+          tbody_parse(node, t)
+          tfoot_parse(node, t)
+          (dl = node.at(ns("./dl"))) && parse(dl, out)
+          node.xpath(ns("./note")).each { |n| parse(n, out) }
+        end
+      end
+      @in_table = false
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+require_relative "xref/xref_anchor"
+require_relative "xref/xref_counter"
+require_relative "xref/xref_gen_seq"
+require_relative "xref/xref_gen"
+require_relative "xref/xref_sect_gen"
+require_relative "class_utils"
+
+module IsoDoc
+  class Xref
+    include XrefGen::Anchor
+    include XrefGen::Blocks
+    include XrefGen::Sections
+
+     def initialize(lang, script, klass, i18n, options = {})
+      @anchors = {}
+      @lang = lang
+      @script = script
+      @klass = klass
+      @options = options
+      @i18n = i18n
+      @labels = @i18n.get
+      @klass.i18n = @i18n
+    end
+
+    def get
+      @anchors
+    end
+
+    def anchor(id, lbl, warning = true)
+      return nil if id.nil? || id.empty?
+      unless @anchors[id]
+        if warning
+          @seen ||= Seen_Anchor.instance
+          @seen.seen(id) or warn "No label has been processed for ID #{id}"
+          @seen.add(id)
+          return "[#{id}]"
+        end
+      end
+      @anchors.dig(id, lbl)
+    end
+
+    # extract names for all anchors, xref and label
+    def parse(docxml)
+      initial_anchor_names(docxml)
+      back_anchor_names(docxml)
+      # preempt clause notes with all other types of note (ISO default)
+      note_anchor_names(docxml.xpath(ns("//table | //figure")))
+      note_anchor_names(docxml.xpath(ns(SECTIONS_XPATH)))
+      example_anchor_names(docxml.xpath(ns(SECTIONS_XPATH)))
+      list_anchor_names(docxml.xpath(ns(SECTIONS_XPATH)))
+    end
+
+    def ns(xpath)
+      Common::ns(xpath)
+    end
+
+    def l10n(a, lang = @lang, script = @script)
+      @i18n.l10n(a, lang, script)
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/xref/xref_anchor.rb

@@ -0,0 +1,56 @@
+require "singleton"
+
+module IsoDoc::XrefGen
+  module Anchor
+    class Seen_Anchor
+      include Singleton
+
+      def initialize
+        @seen = {}
+      end
+
+      def seen(x)
+        @seen.has_key?(x)
+      end
+
+      def add(x)
+        @seen[x] = true
+      end
+    end
+
+    def initialize()
+      @anchors = {}
+    end
+
+    def get_anchors
+      @anchors
+    end
+
+    def anchor_struct_label(lbl, elem)
+      case elem
+      when @labels["appendix"] then l10n("#{elem} #{lbl}")
+      else
+        lbl.to_s
+      end
+    end
+
+    def anchor_struct_xref(lbl, elem)
+      case elem
+      when @labels["formula"] then l10n("#{elem} (#{lbl})")
+      when @labels["inequality"] then l10n("#{elem} (#{lbl})")
+      else
+        l10n("#{elem} #{lbl}")
+      end
+    end
+
+    def anchor_struct(lbl, container, elem, type, unnumbered = false)
+      ret = {}
+      ret[:label] = unnumbered == "true" ? nil : anchor_struct_label(lbl, elem)
+      ret[:xref] = anchor_struct_xref(unnumbered == "true" ? "(??)" : lbl, elem)
+      ret[:xref].gsub!(/ $/, "")
+      ret[:container] = @klass.get_clause_id(container) unless container.nil?
+      ret[:type] = type
+      ret
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/xref/xref_counter.rb

@@ -0,0 +1,74 @@
+require "roman-numerals"
+
+module IsoDoc::XrefGen
+  class Counter
+    def initialize
+      @num = 0
+      @letter = ""
+      @subseq = ""
+      @letter_override = nil
+      @number_override = nil
+    end
+
+    def new_subseq_increment(node)
+      @subseq = node["subsequence"]
+      @num += 1
+      @letter = node["subsequence"] ? "a" : ""
+      if node["number"]
+        /^(?<n>\d*)(?<a>[a-z]*)$/ =~ node["number"]
+        if n || a
+          @letter_override = @letter = a if a
+          @number_override = @num = n.to_i if n
+        else
+          @letter_override = node["number"]
+          @letter = @letter_override if /^[a-z]$/.match(@letter_override)
+        end
+      end
+    end
+
+    def sequence_increment(node)
+      if node["number"]
+        @number_override = node["number"]
+        @num = @number_override.to_i if /^\d+$/.match(@number_override)
+      else
+        @num += 1
+      end
+    end
+
+    def subsequence_increment(node)
+      if node["number"]
+        @letter_override = node["number"]
+        @letter = @letter_override if /^[a-z]$/.match(@letter_override)
+      else
+        @letter = (@letter.ord + 1).chr.to_s
+      end
+    end
+
+    def increment(node)
+      return self if node["unnumbered"]
+      @letter_override = nil
+      @number_override = nil
+      if node["subsequence"] != @subseq
+        new_subseq_increment(node)
+      elsif @letter.empty?
+        sequence_increment(node)
+      else
+        subsequence_increment(node)
+      end
+      self
+    end
+
+    def print
+      "#{@number_override || @num}#{@letter_override || @letter}"
+    end
+
+    def listlabel(depth)
+      return @num.to_s if [2, 7].include? depth
+      return (96 + @num).chr.to_s if [1, 6].include? depth
+      return (64 + @num).chr.to_s if [4, 9].include? depth
+      return RomanNumerals.to_roman(@num).downcase if [3, 8].include? depth
+      return RomanNumerals.to_roman(@num).upcase if [5, 10].include? depth
+      return @num.to_s
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/xref/xref_gen.rb

@@ -0,0 +1,117 @@
+require_relative "xref_gen_seq.rb"
+
+module IsoDoc::XrefGen
+  module Blocks
+    def termnote_label(n)
+      @labels["termnote"].gsub(/%/, n.to_s)
+    end
+
+    def termnote_anchor_names(docxml)
+      docxml.xpath(ns("//term[descendant::termnote]")).each do |t|
+        c = Counter.new
+        t.xpath(ns(".//termnote")).each do |n|
+          return if n["id"].nil? || n["id"].empty?
+          c.increment(n)
+          @anchors[n["id"]] =
+            { label: termnote_label(c.print), type: "termnote",
+              xref: l10n("#{anchor(t['id'], :xref)}, "\
+                         "#{@labels["note_xref"]} #{c.print}") }
+        end
+      end
+    end
+
+    def termexample_anchor_names(docxml)
+      docxml.xpath(ns("//term[descendant::termexample]")).each do |t|
+        examples = t.xpath(ns(".//termexample"))
+        c = Counter.new
+        examples.each do |n|
+          return if n["id"].nil? || n["id"].empty?
+          c.increment(n)
+          idx = examples.size == 1 ? "" : c.print
+          @anchors[n["id"]] = {
+            type: "termexample", label: idx, 
+            xref: l10n("#{anchor(t['id'], :xref)}, "\
+                       "#{@labels["example_xref"]} #{c.print}") }
+        end
+      end
+    end
+
+    SECTIONS_XPATH =
+      "//foreword | //introduction | //acknowledgements | //preface/clause | "\
+      "//preface/terms | preface/definitions | preface/references | "\
+      "//sections/terms | //annex | "\
+      "//sections/clause | //sections/definitions | "\
+      "//bibliography/references | //bibliography/clause".freeze
+
+    CHILD_NOTES_XPATH =
+      "./*[not(self::xmlns:clause) and not(self::xmlns:appendix) and "\
+      "not(self::xmlns:terms) and not(self::xmlns:definitions)]//xmlns:note | "\
+      "./xmlns:note".freeze
+
+    def note_anchor_names(sections)
+      sections.each do |s|
+        notes = s.xpath(CHILD_NOTES_XPATH)
+        c = Counter.new
+        notes.each do |n|
+          next if @anchors[n["id"]] || n["id"].nil? || n["id"].empty?
+          idx = notes.size == 1 ? "" : " #{c.increment(n).print}"
+          @anchors[n["id"]] = anchor_struct(idx, n, @labels["note_xref"], 
+                                            "note", false)
+        end
+        note_anchor_names(s.xpath(ns(CHILD_SECTIONS)))
+      end
+    end
+
+    CHILD_EXAMPLES_XPATH =
+      "./*[not(self::xmlns:clause) and not(self::xmlns:appendix) and "\
+      "not(self::xmlns:terms) and not(self::xmlns:definitions)]//"\
+      "xmlns:example | ./xmlns:example".freeze
+
+    CHILD_SECTIONS = "./clause | ./appendix | ./terms | ./definitions | ./references"
+
+    def example_anchor_names(sections)
+      sections.each do |s|
+        notes = s.xpath(CHILD_EXAMPLES_XPATH)
+        c = Counter.new
+        notes.each do |n|
+          next if @anchors[n["id"]]
+          next if n["id"].nil? || n["id"].empty?
+          idx = notes.size == 1 ? "" : " #{c.increment(n).print}"
+          @anchors[n["id"]] = anchor_struct(idx, n, @labels["example_xref"],
+                                            "example", n["unnumbered"])
+        end
+        example_anchor_names(s.xpath(ns(CHILD_SECTIONS)))
+      end
+    end
+
+    def list_anchor_names(sections)
+      sections.each do |s|
+        notes = s.xpath(ns(".//ol")) - s.xpath(ns(".//clause//ol")) -
+          s.xpath(ns(".//appendix//ol")) - s.xpath(ns(".//ol//ol"))
+        c = Counter.new
+        notes.each do |n|
+          next if n["id"].nil? || n["id"].empty?
+          idx = notes.size == 1 ? "" : " #{c.increment(n).print}"
+          @anchors[n["id"]] = anchor_struct(idx, n, @labels["list"], "list", false)
+          list_item_anchor_names(n, @anchors[n["id"]], 1, "", notes.size != 1)
+        end
+        list_anchor_names(s.xpath(ns(CHILD_SECTIONS)))
+      end
+    end
+
+    def list_item_anchor_names(list, list_anchor, depth, prev_label, refer_list)
+      c = Counter.new
+      list.xpath(ns("./li")).each do |li|
+        label = c.increment(li).listlabel(depth)
+        label = "#{prev_label}.#{label}" unless prev_label.empty?
+        label = "#{list_anchor[:xref]} #{label}" if refer_list
+        li["id"] and @anchors[li["id"]] =
+          { xref: "#{label})", type: "listitem", 
+            container: list_anchor[:container] }
+        li.xpath(ns("./ol")).each do |ol|
+          list_item_anchor_names(ol, list_anchor, depth + 1, label, false)
+        end
+      end
+    end
+  end
+end