metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/function/blocks_example_note.rb

@@ -0,0 +1,107 @@
+module IsoDoc::Function
+  module Blocks
+    def example_label(node, div, name)
+      return if name.nil?
+      div.p **{ class: "example-title" } do |p|
+        name.children.each { |n| parse(n, div) }
+      end
+    end
+
+    EXAMPLE_TBL_ATTR =
+      { class: "example_label", style: "width:82.8pt;padding:0 0 0 0;\
+        margin-left:0pt;vertical-align:top;" }.freeze
+
+    def example_div_attr(node)
+      attr_code(id: node["id"], class: "example", style: keep_style(node))
+    end
+
+    # used if we are boxing examples
+    def example_div_parse(node, out)
+      out.div **example_div_attr(node) do |div|
+        example_label(node, div, node.at(ns("./name")))
+        node.children.each do |n|
+          parse(n, div) unless n.name == "name"
+        end
+      end
+    end
+
+    def example_table_attr(node)
+      attr_code(id: node["id"], class: "example",
+                style: "border-collapse:collapse;border-spacing:0;"\
+                "#{keep_style(node)}" )
+    end
+
+    EXAMPLE_TD_ATTR =
+      { style: "vertical-align:top;padding:0;", class: "example" }.freeze
+
+    def example_table_parse(node, out)
+      out.table **example_table_attr(node) do |t|
+        t.tr do |tr|
+          tr.td **EXAMPLE_TBL_ATTR do |td|
+            example_label(node, td, node.at(ns("./name")))
+          end
+          tr.td **EXAMPLE_TD_ATTR do |td|
+            node.children.each { |n| parse(n, td) unless n.name == "name" }
+          end
+        end
+      end
+    end
+
+    def example_parse(node, out)
+      example_div_parse(node, out)
+    end
+
+    def note_delim
+      ""
+    end
+
+    def note_p_parse(node, div)
+      name = node&.at(ns("./name"))&.remove
+      div.p do |p|
+        name and p.span **{ class: "note_label" } do |s|
+          name and name.children.each { |n| parse(n, s) }
+          s << note_delim
+        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
+      name and div.p do |p|
+        p.span **{ class: "note_label" } do |s|
+          name.children.each { |n| parse(n, s) }
+          s << note_delim
+        end
+        insert_tab(p, 1)
+      end
+      node.children.each { |n| parse(n, div) }
+    end
+
+    def keep_style(node)
+      ret = ""
+      node["keep-with-next"] == "true" and
+        ret += "page-break-after: avoid;"
+      node["keep-lines-together"] == "true" and
+        ret += "page-break-inside: avoid;"
+      return nil if ret.empty?
+      ret
+    end
+
+    def note_attrs(node)
+      attr_code(id: node["id"], class: "Note", style: keep_style(node))
+    end
+
+    def note_parse(node, out)
+      @note = true
+      out.div **note_attrs(node) do |div|
+        node&.at(ns("./*[local-name() != 'name'][1]"))&.name == "p" ?
+        #node.first_element_child.name == "p" ?
+          note_p_parse(node, div) : note_parse1(node, div)
+      end
+      @note = false
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/function/cleanup.rb

@@ -0,0 +1,218 @@
+module IsoDoc::Function
+  module Cleanup
+    def textcleanup(docxml)
+      docxml = termref_cleanup(passthrough_cleanup(docxml))
+    end
+
+    def termref_cleanup(docxml)
+      docxml.
+        gsub(%r{\s*\[/TERMREF\]\s*</p>\s*<p>\s*\[TERMREF\]}, "; ").
+        gsub(/\[TERMREF\]\s*/, l10n("[#{@i18n.source}: ")).
+        gsub(/\s*\[MODIFICATION\]\s*\[\/TERMREF\]/, l10n(", #{@i18n.modified} [/TERMREF]")).
+        gsub(%r{\s*\[\/TERMREF\]\s*}, l10n("]")).
+        gsub(/\s*\[MODIFICATION\]/, l10n(", #{@i18n.modified} &mdash; "))
+    end
+
+    def passthrough_cleanup(docxml)
+      docxml.split(%r{(<passthrough>|</passthrough>)}).each_slice(4).map do |a|
+        a.size > 2 and a[2] = HTMLEntities.new.decode(a[2])
+        [a[0], a[2]]
+      end.join
+    end
+
+    def cleanup(docxml)
+      @i18n ||= i18n_init(@lang, @script) 
+      comment_cleanup(docxml)
+      footnote_cleanup(docxml)
+      inline_header_cleanup(docxml)
+      figure_cleanup(docxml)
+      table_cleanup(docxml)
+      symbols_cleanup(docxml)
+      example_cleanup(docxml)
+      admonition_cleanup(docxml)
+    end
+
+    def table_long_strings_cleanup(docxml)
+      return unless @break_up_urls_in_tables == true
+      docxml.xpath("//td | //th").each do |d|
+        d.traverse do |n|
+          next unless n.text?
+          n.replace(HTMLEntities.new.encode(
+            break_up_long_strings(n.text)))
+        end
+      end
+    end
+
+    def break_up_long_strings(t)
+      return t if t.match(/^\s*$/)
+      t.split(/(?=\s)/).map do |w|
+        (/^\s*$/.match(t) or w.size < 30) ? w :
+          w.scan(/.{,30}/).map do |w1|
+          (w1.size < 30) ? w1 : break_up_long_strings1(w1)
+        end.join
+      end.join
+    end
+
+    def break_up_long_strings1(w1)
+      s = w1.split(%r{(?<=[,.?+;/=])})
+      if s.size == 1 then w1 + " "
+      else
+        s[-1] = " " + s[-1]
+        s.join
+      end
+    end
+
+    def admonition_cleanup(docxml)
+      docxml.xpath("//div[@class = 'Admonition'][title]").each do |d|
+        title = d.at("./title")
+        n = title.next_element
+        n&.children&.first&.add_previous_sibling(title.remove.text + "&mdash;")
+      end
+      docxml
+    end
+
+    def example_cleanup(docxml)
+      docxml.xpath("//table[@class = 'example']//p[not(@class)]").each do |p|
+        p["class"] = "example"
+      end
+      docxml
+    end
+
+    def figure_get_or_make_dl(t)
+      dl = t.at(".//dl")
+      if dl.nil?
+        t.add_child("<p><b>#{@i18n.key}</b></p><dl></dl>")
+        dl = t.at(".//dl")
+      end
+      dl
+    end
+
+    FIGURE_WITH_FOOTNOTES =
+      "//div[@class = 'figure'][descendant::aside]"\
+      "[not(descendant::div[@class = 'figure'])]".freeze
+
+    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']/..")
+      dt = key.add_child("<dt></dt>").first
+      dd = key.add_child("<dd></dd>").first
+      fnref.parent = dt
+      aside.xpath(".//p").each do |a|
+        a.delete("class")
+        a.parent = dd
+      end
+    end
+
+    # move footnotes into key, and get rid of footnote reference
+    # since it is in diagram
+    def figure_cleanup(docxml)
+      docxml.xpath(FIGURE_WITH_FOOTNOTES).each do |f|
+        next unless f.at(".//aside[not(ancestor::p[@class = 'FigureTitle'])]")
+        key = figure_get_or_make_dl(f)
+        f.xpath(".//aside").each do |aside|
+          figure_aside_process(f, aside, key)
+        end
+      end
+      docxml
+    end
+
+    def inline_header_cleanup(docxml)
+      docxml.xpath('//span[@class="zzMoveToFollowing"]').each do |x|
+        x.delete("class")
+        n = x.next_element
+        if n.nil?
+          x.name = "p"
+        else
+          n.children.first.previous = x.remove
+        end
+      end
+      docxml
+    end
+
+    def footnote_cleanup(docxml)
+      docxml.xpath('//a[@class = "FootnoteRef"]/sup').each_with_index do |x, i|
+        x.content = (i + 1).to_s
+      end
+      docxml
+    end
+
+    def merge_fnref_into_fn_text(a)
+      fn = a.at('.//span[@class="TableFootnoteRef"]/..')
+      n = fn.next_element
+      n&.children&.first&.add_previous_sibling(fn.remove)
+    end
+
+    def table_footnote_cleanup(docxml)
+      docxml.xpath("//table[descendant::aside]").each do |t|
+        t.xpath(".//aside").each do |a|
+          merge_fnref_into_fn_text(a)
+          a.name = "div"
+          a["class"] = "TableFootnote"
+          t << a.remove
+        end
+      end
+      # preempt html2doc putting MsoNormal there
+      docxml.xpath("//p[not(self::*[@class])]"\
+                   "[ancestor::*[@class = 'TableFootnote']]").each do |p|
+        p["class"] = "TableFootnote"
+      end
+    end
+
+    def remove_bottom_border(td)
+      td["style"] =
+        td["style"].gsub(/border-bottom:[^;]+;/, "border-bottom:0pt;")
+    end
+
+    def table_get_or_make_tfoot(t)
+      tfoot = t.at(".//tfoot")
+      if tfoot.nil?
+        t.add_child("<tfoot></tfoot>")
+        tfoot = t.at(".//tfoot")
+      else
+        tfoot.xpath(".//td | .//th").each { |td| remove_bottom_border(td) }
+      end
+      tfoot
+    end
+
+    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;border-bottom:#{IsoDoc::Function::Table::SW} 1.5pt;}
+      tfoot.add_child("<tr><td colspan='#{cols}' style='#{style}'/></tr>")
+      tfoot.xpath(".//td").last
+    end
+
+    def table_note_cleanup(docxml)
+      docxml.xpath("//table[div[@class = 'Note' or "\
+                   "@class = 'TableFootnote']]").each do |t|
+        tfoot = table_get_or_make_tfoot(t)
+        insert_here = new_fullcolspan_row(t, tfoot)
+        t.xpath("div[@class = 'Note' or @class = 'TableFootnote']").each do |d|
+          d.parent = insert_here
+        end
+      end
+    end
+
+    def table_cleanup(docxml)
+      table_footnote_cleanup(docxml)
+      table_note_cleanup(docxml)
+      table_long_strings_cleanup(docxml)
+      docxml
+    end
+
+    def symbols_cleanup(docxml)
+    end
+
+    def table_footnote_reference_format(a)
+      a
+    end
+
+    def footnote_reference_format(a)
+      a
+    end
+  end
+end

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

@@ -0,0 +1,155 @@
+require_relative "inline_simple"
+
+module IsoDoc::Function
+  module Inline
+    def link_parse(node, out)
+      out.a **attr_code(href: node["target"], title: node["alt"]) do |l|
+        if node.text.empty?
+          l << node["target"].sub(/^mailto:/, "")
+        else
+          node.children.each { |n| parse(n, l) }
+        end
+      end
+    end
+
+    def callout_parse(node, out)
+      out << " &lt;#{node.text}&gt;"
+    end
+
+    def no_locality_parse(node, out)
+      node.children.each do |n|
+        parse(n, out) unless %w{locality localityStack}.include? n.name
+      end
+    end
+
+    def xref_parse(node, out)
+      target = /#/.match(node["target"]) ? node["target"].sub(/#/, ".html#") :
+        "##{node["target"]}"
+        out.a(**{ "href": target }) { |l| no_locality_parse(node, l) }
+    end
+
+    def suffix_url(url)
+      return url if %r{^http[s]?://}.match(url)
+      url.sub(/#{File.extname(url)}$/, ".html")
+    end
+
+    def eref_target(node)
+      href = "#" + node["bibitemid"]
+      url = node.at(ns("//bibitem[@id = '#{node['bibitemid']}']/"\
+                       "uri[@type = 'citation']"))
+      return href unless url
+      href = suffix_url(url.text)
+      anchor = node&.at(ns(".//locality[@type = 'anchor']"))&.text
+      anchor and href += "##{anchor}"
+      href
+    end
+
+    def eref_parse(node, out)
+      href = eref_target(node)
+      if node["type"] == "footnote"
+        out.sup do |s|
+          s.a(**{ "href": href }) { |l| no_locality_parse(node, l) }
+        end
+      else
+        out.a(**{ "href": href }) { |l| no_locality_parse(node, l) }
+      end
+    end
+
+    def origin_parse(node, out)
+      if t = node.at(ns("./termref"))
+        termrefelem_parse(t, out)
+      else
+        eref_parse(node, out)
+      end
+    end
+
+    def termrefelem_parse(node, out)
+      out << "Termbase #{node['base']}, term ID #{node['target']}"
+    end
+
+    def concept_parse(node, out)
+      content = node.first_element_child.children.select do |c|
+        !%w{locality localityStack}.include? c.name 
+      end.select { |c| !c.text? || /\S/.match(c) }
+      if content.empty?
+        out << "[Term defined in "
+        parse(node.first_element_child, out)
+        out << "]"
+      else
+        content.each { |n| parse(n, out) }
+      end
+    end
+
+    def stem_parse(node, out)
+      ooml = if node["type"] == "AsciiMath"
+               "#{@openmathdelim}#{HTMLEntities.new.encode(node.text)}"\
+                 "#{@closemathdelim}"
+             elsif node["type"] == "MathML" then node.first_element_child.to_s
+             else
+               HTMLEntities.new.encode(node.text)
+             end
+      out.span **{ class: "stem" } do |span|
+        span.parent.add_child ooml
+      end
+    end
+
+    def image_title_parse(out, caption)
+      unless caption.nil?
+        out.p **{ class: "FigureTitle", style: "text-align:center;" } do |p|
+          p.b { |b| b << caption.to_s }
+        end
+      end
+    end
+
+    def image_parse(node, out, caption)
+      attrs = { src: node["src"],
+                height: node["height"] || "auto",
+                width: node["width"] || "auto",
+                title: node["title"],
+                alt: node["alt"]  }
+      out.img **attr_code(attrs)
+      image_title_parse(out, caption)
+    end
+
+    def smallcap_parse(node, xml)
+      xml.span **{ style: "font-variant:small-caps;" } do |s|
+        node.children.each { |n| parse(n, s) }
+      end
+    end
+
+    def text_parse(node, out)
+      return if node.nil? || node.text.nil?
+      text = node.to_s
+      text = text.gsub("\n", "<br/>").gsub("<br/> ", "<br/>&nbsp;").
+        gsub(/[ ](?=[ ])/, "&nbsp;") if in_sourcecode
+      out << text
+    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 variant_parse(node, out)
+      if node["lang"] == @lang && node["script"] == @script
+        node.children.each { |n| parse(n, out) }
+      else
+        return if found_matching_variant_sibling(node)
+        return unless !node.at("./preceding-sibling::xmlns:variant")
+        node.children.each { |n| parse(n, out) }
+      end
+    end
+
+    def found_matching_variant_sibling(node)
+      prev = node.xpath("./preceding-sibling::xmlns:variant")
+      foll = node.xpath("./following-sibling::xmlns:variant")
+      found = false
+      (prev + foll).each do |n|
+        found = true if n["lang"] == @lang && n["script"] == @script
+      end
+      found
+    end
+  end
+end