metanorma-cli 1.3.3.1 → 1.3.4

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

@@ -0,0 +1,83 @@
+module IsoDoc::HtmlFunction
+  module Footnotes
+
+    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: "fn:#{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: "fn:#{fnid}", class: "footnote" } 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 **{ class: "footnote" } do |a|
+        a << make_table_footnote_text(node, tid + fn, fn)
+      end
+      @in_footnote = false
+      @seen_footnote << (tid + fn)
+    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
+      attrs = { class: "FootnoteRef", href: "#fn:#{fn}" }
+      out.a **attrs do |a|
+        a.sup { |sup| sup << fn }
+      end
+      make_footnote(node, 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/html_function/html.rb

@@ -0,0 +1,115 @@
+require "fileutils"
+require "base64"
+
+module IsoDoc::HtmlFunction
+  module Html
+    def convert1(docxml, filename, dir)
+      noko do |xml|
+        xml.html **{ lang: "#{@lang}" } do |html|
+          info docxml, nil
+          populate_css()
+          html.head { |head| define_head head, filename, dir }
+          make_body(html, docxml)
+        end
+      end.join("\n")
+    end
+
+    def make_body1(body, _docxml)
+      body.div **{ class: "title-section" } do |div1|
+        div1.p { |p| p << "&nbsp;" } # placeholder
+      end
+      section_break(body)
+    end
+
+    def make_body2(body, docxml)
+      body.div **{ class: "prefatory-section" } do |div2|
+        div2.p { |p| p << "&nbsp;" } # placeholder
+      end
+      section_break(body)
+    end
+
+    def make_body3(body, docxml)
+      body.div **{ class: "main-section" } do |div3|
+        boilerplate docxml, div3
+        abstract docxml, div3
+        foreword docxml, div3
+        introduction docxml, div3
+        preface docxml, div3
+        acknowledgements docxml, div3
+        middle docxml, div3
+        footnotes div3
+        comments div3
+      end
+    end
+
+    def googlefonts()
+      <<~HEAD.freeze
+      <link href="https://fonts.googleapis.com/css?family=Overpass:300,300i,600,900" rel="stylesheet">
+    <link href="https://fonts.googleapis.com/css?family=Lato:400,400i,700,900" rel="stylesheet">
+      HEAD
+    end
+
+    def html_head()
+      <<~HEAD.freeze
+    <title>#{@meta&.get&.dig(:doctitle)}</title>
+    <script type="text/javascript" src="https://ajax.googleapis.com/ajax/libs/jquery/3.3.1/jquery.min.js"></script>
+
+    <!--TOC script import-->
+    <script type="text/javascript"  src="https://cdn.rawgit.com/jgallen23/toc/0.3.2/dist/toc.min.js"></script>
+    <script type="text/javascript">#{toclevel}</script>
+
+    <!--Google fonts-->
+      #{googlefonts}
+    <!--Font awesome import for the link icon-->
+    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.0.8/css/solid.css" integrity="sha384-v2Tw72dyUXeU3y4aM2Y0tBJQkGfplr39mxZqlTBDUZAb9BGoC40+rdFCG0m10lXk" crossorigin="anonymous">
+    <link rel="stylesheet" href="https://use.fontawesome.com/releases/v5.0.8/css/fontawesome.css" integrity="sha384-q3jl8XQu1OpdLgGFvNRnPdj5VIlCvgsDQTQB6owSOHWlAurxul7f+JpUOVdAiJ5P" crossorigin="anonymous">
+    <style class="anchorjs"></style>
+      HEAD
+    end
+
+    def html_button()
+      '<button onclick="topFunction()" id="myBtn" '\
+        'title="Go to top">Top</button>'.freeze
+    end
+
+    def html_main(docxml)
+      docxml.at("//head").add_child(html_head())
+      d = docxml.at('//div[@class="main-section"]')
+      d.name = "main"
+      d.children.empty? or d.children.first.previous = html_button()
+    end
+
+    def sourcecodelang(lang)
+      return unless lang
+      case lang.downcase
+      when "javascript" then "lang-js"
+      when "c" then "lang-c"
+      when "c+" then "lang-cpp"
+      when "console" then "lang-bsh"
+      when "ruby" then "lang-rb"
+      when "html" then "lang-html"
+      when "java" then "lang-java"
+      when "xml" then "lang-xml"
+      when "perl" then "lang-perl"
+      when "python" then "lang-py"
+      when "xsl" then "lang-xsl"
+      else
+        ""
+      end
+    end
+
+    def sourcecode_parse(node, out)
+      name = node.at(ns("./name"))
+      class1 = "prettyprint #{sourcecodelang(node&.at(ns('./@lang'))&.value)}"
+      out.pre **sourcecode_attrs(node).merge(class: class1) do |div|
+        @sourcecode = true
+        node.children.each { |n| parse(n, div) unless n.name == "name" }
+        @sourcecode = false
+      end
+      sourcecode_name_parse(node, out, name)
+    end
+
+    def table_long_strings_cleanup(docxml)
+    end
+  end
+end

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

@@ -0,0 +1,243 @@
+module IsoDoc::HtmlFunction
+  module Html
+    def postprocess(result, filename, dir)
+      result = from_xhtml(cleanup(to_xhtml(textcleanup(result))))
+      toHTML(result, filename)
+      @files_to_delete.each { |f| FileUtils.rm_rf f }
+    end
+
+    def script_cdata(result)
+      result.gsub(%r{<script([^>]*)>\s*<!\[CDATA\[}m, "<script\\1>").
+        gsub(%r{\]\]>\s*</script>}, "</script>").
+        gsub(%r{<!\[CDATA\[\s*<script([^>]*)>}m, "<script\\1>").
+        gsub(%r{</script>\s*\]\]>}, "</script>")
+    end
+
+    def toHTML(result, filename)
+      result = (from_xhtml(html_cleanup(to_xhtml(result))))
+      #result = populate_template(result, :html)
+      result = from_xhtml(move_images(to_xhtml(result)))
+      result = html5(script_cdata(inject_script(result)))
+      File.open(filename, "w:UTF-8") { |f| f.write(result) }
+    end
+
+    def html5(doc)
+      doc.sub(%r{<!DOCTYPE html [^>]+>}, "<!DOCTYPE html>").
+        sub(%r{<\?xml[^>]+>}, "")
+    end
+
+    def html_cleanup(x)
+      footnote_format(footnote_backlinks(html_toc(
+        term_header((html_footnote_filter(html_preface(htmlstyle(x))))))
+                        ))
+    end
+
+    def htmlstylesheet
+      @htmlstylesheet.open
+      stylesheet = @htmlstylesheet.read
+      xml = Nokogiri::XML("<style/>")
+      xml.children.first << Nokogiri::XML::Comment.new(xml, "\n#{stylesheet}\n")
+      @htmlstylesheet.close!
+      xml.root.to_s
+    end
+
+    def htmlstyle(docxml)
+      return docxml unless @htmlstylesheet
+      title = docxml.at("//*[local-name() = 'head']/*[local-name() = 'title']")
+      head = docxml.at("//*[local-name() = 'head']")
+      head << htmlstylesheet
+      docxml
+    end
+
+    def html_preface(docxml)
+      html_cover(docxml) if @htmlcoverpage
+      html_intro(docxml) if @htmlintropage
+      docxml.at("//body") << mathjax(@openmathdelim, @closemathdelim)
+      docxml.at("//body") << sourcecode_highlighter
+      html_main(docxml)
+      authority_cleanup(docxml)
+      docxml
+    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 { |h| h["class"] = "IntroTitle" }
+      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 html_cover(docxml)
+      doc = to_xhtml_fragment(File.read(@htmlcoverpage, encoding: "UTF-8"))
+      d = docxml.at('//div[@class="title-section"]')
+      #d.children.first.add_previous_sibling doc.to_xml(encoding: "US-ASCII")
+      d.children.first.add_previous_sibling populate_template(doc.to_xml(encoding: "US-ASCII"), :html)
+    end
+
+    def html_intro(docxml)
+      doc = to_xhtml_fragment(File.read(@htmlintropage, encoding: "UTF-8"))
+      d = docxml.at('//div[@class="prefatory-section"]')
+      #d.children.first.add_previous_sibling doc.to_xml(encoding: "US-ASCII")
+      d.children.first.add_previous_sibling populate_template(doc.to_xml(encoding: "US-ASCII"), :html)
+    end
+
+    def html_toc_entry(level, header)
+      %(<li class="#{level}"><a href="##{header['id']}">\
+      #{header_strip(header)}</a></li>)
+    end
+
+    def toclevel_classes
+      (1..@htmlToClevels).inject([]) { |m, i| m << "h#{i}" }
+    end
+
+    def toclevel
+      ret = toclevel_classes.map { |l| "#{l}:not(:empty):not(.TermNum):not(.noTOC)" }
+      <<~HEAD.freeze
+    function toclevel() { return "#{ret.join(',')}";}
+      HEAD
+    end
+
+    # needs to be same output as toclevel
+    def html_toc(docxml)
+      idx = docxml.at("//div[@id = 'toc']") or return docxml
+      toc = "<ul>"
+      path = toclevel_classes.map do |l|
+        "//main//#{l}[not(@class = 'TermNum')][not(@class = 'noTOC')][text()]"
+      end
+      docxml.xpath(path.join(" | ")).each_with_index do |h, tocidx|
+        h["id"] ||= "toc#{tocidx}"
+        toc += html_toc_entry(h.name, h)
+      end
+      idx.children = "#{toc}</ul>"
+      docxml
+    end
+
+    # presupposes that the image source is local
+    def move_images(docxml)
+      FileUtils.rm_rf tmpimagedir
+      FileUtils.mkdir tmpimagedir
+      docxml.xpath("//*[local-name() = 'img']").each do |i|
+        i["width"], i["height"] = Html2Doc.image_resize(i, image_localfile(i),
+                                                        @maxheight, @maxwidth)
+        next if /^data:image/.match i["src"]
+        @datauriimage ? datauri(i) : move_image1(i)
+      end
+      docxml
+    end
+
+    def datauri(i)
+      type = i["src"].split(".")[-1]
+      bin = IO.binread(image_localfile(i))
+      data = Base64.strict_encode64(bin)
+      i["src"] = "data:image/#{type};base64,#{data}"
+    end
+
+    def image_suffix(i)
+      type = i["mimetype"]&.sub(%r{^[^/*]+/}, "")
+      matched = /\.(?<suffix>[^. \r\n\t]+)$/.match i["src"]
+      type and !type.empty? and return type
+      !matched.nil? and matched[:suffix] and return matched[:suffix]
+      "png"
+    end
+
+    def move_image1(i)
+      suffix = image_suffix(i)
+      uuid = UUIDTools::UUID.random_create.to_s
+      fname = "#{uuid}.#{suffix}"
+      new_full_filename = File.join(tmpimagedir, fname)
+      local_filename = image_localfile(i)
+      FileUtils.cp local_filename, new_full_filename
+      i["src"] = File.join(rel_tmpimagedir, fname)
+    end
+
+    def inject_script(doc)
+      return doc unless @scripts
+      scripts = File.read(@scripts, encoding: "UTF-8")
+      a = doc.split(%r{</body>})
+      a[0] + scripts + "</body>" + a[1]
+    end
+
+    def update_footnote_filter(fn, x, i, seen)
+      if seen[fn.text]
+        x.at("./sup").content = seen[fn.text][:num].to_s
+        fn.remove unless x["href"] == seen[fn.text][:href]
+        x["href"] = seen[fn.text][:href]
+      else
+        seen[fn.text] = { num: i, href: x["href"] }
+        x.at("./sup").content = i.to_s
+        i += 1
+      end
+      [i, seen]
+    end
+
+    def html_footnote_filter(docxml)
+      seen = {}
+      i = 1
+      docxml.xpath('//a[@class = "FootnoteRef"]').each do |x|
+        fn = docxml.at(%<//*[@id = '#{x['href'].sub(/^#/, '')}']>) || next
+        i, seen = update_footnote_filter(fn, x, i, seen)
+      end
+      docxml
+    end
+
+    def footnote_backlinks(docxml)
+      seen = {}
+      docxml.xpath('//a[@class = "FootnoteRef"]').each_with_index do |x, i|
+        seen[x["href"]] and next or seen[x["href"]] = true
+        fn = docxml.at(%<//*[@id = '#{x['href'].sub(/^#/, '')}']>) || next
+        xdup = x.dup
+        xdup.remove["id"]
+        fn.elements.first.children.first.previous = xdup
+        x["id"] ||= "fnref:#{i + 1}"
+        fn.add_child "<a href='##{x['id']}'>&#x21A9;</a>"
+      end
+      docxml
+    end
+
+    def footnote_format(docxml)
+      docxml.xpath("//a[@class = 'FootnoteRef']/sup").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
+
+    def sourcecode_highlighter
+      '<script src="https://cdn.rawgit.com/google/code-prettify/master/'\
+        'loader/run_prettify.js"></script>'
+    end
+
+    MATHJAX_ADDR =
+      "https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/latest.js".freeze
+    MATHJAX = <<~"MATHJAX".freeze
+      <script type="text/x-mathjax-config">
+        MathJax.Hub.Config({
+          asciimath2jax: { delimiters: [['OPEN', 'CLOSE']] }
+       });
+      </script>
+      <script src="#{MATHJAX_ADDR}?config=MML_HTMLorMML-full" async="async"></script>
+    MATHJAX
+
+    def mathjax(open, close)
+      MATHJAX.gsub("OPEN", open).gsub("CLOSE", close)
+    end
+
+    def term_header(docxml)
+      %w(h1 h2 h3 h4 h5 h6 h7 h8).each do |h|
+        docxml.xpath("//p[@class = 'TermNum'][../#{h}]").each do |p|
+          p.name = "h#{h[1].to_i + 1}"
+        end
+      end
+      docxml
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+require "yaml"
+
+# TODO: Cleanup and generalize
+module IsoDoc
+  class I18n
+    def load_yaml(lang, script, i18nyaml = nil)
+      ret = load_yaml1(lang, script)
+      return ret.merge(YAML.load_file(i18nyaml)) if i18nyaml
+      ret
+    end
+
+    def load_yaml1(lang, script)
+      if lang == "en"
+        YAML.load_file(File.join(File.dirname(__FILE__),
+                                 "../isodoc-yaml/i18n-en.yaml"))
+      elsif lang == "fr"
+        YAML.load_file(File.join(File.dirname(__FILE__),
+                                 "../isodoc-yaml/i18n-fr.yaml"))
+      elsif lang == "zh" && script == "Hans"
+        YAML.load_file(File.join(File.dirname(__FILE__),
+                                 "../isodoc-yaml/i18n-zh-Hans.yaml"))
+      else
+        YAML.load_file(File.join(File.dirname(__FILE__),
+                                 "../isodoc-yaml/i18n-en.yaml"))
+      end
+    end
+
+    def get
+      @labels
+    end
+
+    def set(x, y)
+      @labels[x] = y
+    end
+
+    def initialize(lang, script, i18nyaml = nil)
+      @lang = lang
+      @script = script
+      y = load_yaml(lang, script, i18nyaml)
+      @labels = y
+      @labels["language"] = @lang
+      @labels["script"] = @script
+      @labels.each do |k, v|
+        self.class.send(:define_method, k.downcase) { v }
+      end
+=begin
+      @term_def_boilerplate = y["term_def_boilerplate"]
+      @scope_lbl = y["scope"]
+      @symbols_lbl = y["symbols"]
+      @table_of_contents_lbl = y["table_of_contents"]
+      @introduction_lbl = y["introduction"]
+      @foreword_lbl = y["foreword"]
+      @abstract_lbl = y["abstract"]
+      @termsdef_lbl = y["termsdef"]
+      @termsdefsymbols_lbl = y["termsdefsymbols"]
+      @normref_lbl = y["normref"]
+      @bibliography_lbl = y["bibliography"]
+      @clause_lbl = y["clause"]
+      @annex_lbl = y["annex"]
+      @appendix_lbl = y["appendix"]
+      @no_terms_boilerplate = y["no_terms_boilerplate"]
+      @internal_terms_boilerplate = y["internal_terms_boilerplate"]
+      @norm_with_refs_pref = y["norm_with_refs_pref"]
+      @norm_empty_pref = y["norm_empty_pref"]
+      @external_terms_boilerplate = y["external_terms_boilerplate"]
+      @internal_external_terms_boilerplate =
+        y["internal_external_terms_boilerplate"]
+      @note_lbl = y["note"]
+      @note_xref_lbl = y["note_xref"]
+      @termnote_lbl = y["termnote"]
+      @figure_lbl = y["figure"]
+      @list_lbl = y["list"]
+      @formula_lbl = y["formula"]
+      @inequality_lbl = y["inequality"]
+      @table_lbl = y["table"]
+      @key_lbl = y["key"]
+      @example_lbl = y["example"]
+      @example_xref_lbl = y["example_xref"]
+      @where_lbl = y["where"]
+      @wholeoftext_lbl = y["wholeoftext"]
+      @draft_lbl = y["draft_label"]
+      @inform_annex_lbl = y["inform_annex"]
+      @norm_annex_lbl = y["norm_annex"]
+      @modified_lbl = y["modified"]
+      @deprecated_lbl = y["deprecated"]
+      @source_lbl = y["source"]
+      @and_lbl = y["and"]
+      @all_parts_lbl = y["all_parts"]
+      @permission_lbl = y["permission"]
+      @recommendation_lbl = y["recommendation"]
+      @requirement_lbl = y["requirement"]
+      @locality = y["locality"]
+      @admonition = y["admonition"]
+=end
+    end
+
+    def self.l10n(x, lang = @lang, script = @script)
+      l10n(x, lang, script)
+    end
+
+    # TODO: move to localization file
+    # function localising spaces and punctuation.
+    # Not clear if period needs to be localised for zh
+    def l10n(x, lang = @lang, script = @script)
+      if lang == "zh" && script == "Hans"
+        xml = Nokogiri::HTML::DocumentFragment.parse(x)
+        xml.traverse do |n|
+          next unless n.text?
+          n.replace(n.text.gsub(/ /, "").gsub(/:/, "：").gsub(/,/, "、").
+                    gsub(/\(/, "（").gsub(/\)/, "）").
+                    gsub(/\[/, "【").gsub(/\]/, "】"))
+        end
+        xml.to_xml.gsub(/<b>/, "").gsub("</b>", "").gsub(/<\?[^>]+>/, "")
+      else
+        x
+      end
+    end
+
+    #module_function :l10n
+
+  end
+end