metanorma-cli 1.3.3.1 → 1.3.4

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/base_style/typography.scss

@@ -0,0 +1,67 @@
+@mixin bodyStyle1($fontSize, $lineHeight, $colorText, $colorBackground, $fontWeight: 400) {
+  margin-left: auto;
+  margin-right: auto;
+  max-width: 100%;
+  font-size: $fontSize;
+  font-weight: $fontWeight;
+  line-height: $lineHeight;
+  color: $colorText;
+  background-color: $colorBackground;
+
+  main {
+    margin: 0 3em 0 6em;
+  }
+
+}
+
+@mixin elementStyles($color, $colorHighlightBg, $colorHighlightFg) {
+  a, a:visited {
+    text-decoration: none;
+    color: $color;
+  }
+  a:hover {
+    color: $colorHighlightFg;
+    background: $colorHighlightBg;
+    box-shadow: 3px 0 0 $colorHighlightBg, -3px 0 0 $colorHighlightBg;
+  }
+  ::selection,
+  ::-moz-selection {
+    background: $colorHighlightBg;
+    color: $colorHighlightFg;
+  }
+}
+
+@mixin rule($thickness, $color, $margin: 2em 0, $clear: false) {
+  width: 100%;
+  height: $thickness;
+  background-color: $color;
+
+  @if $margin {
+    margin: $margin;
+  }
+
+  // Obsolete (?)
+  @if $clear {
+    clear: both;
+  }
+}
+
+@mixin table($border: none) {
+  width: 100%;
+  font-weight: 300;
+  margin: 1em 0 2em 0;
+  margin-left: auto;
+  margin-right: auto;
+  padding-right: 2em;
+
+  &, th, td {
+    border: $border;
+    font-size: 0.95em;
+  }
+  th, td {
+    padding: 1em;
+  }
+  td.header {
+    font-weigth: 400;
+  }
+}

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

@@ -0,0 +1,30 @@
+module IsoDoc
+  module ClassUtils
+    def date_range(date)
+      from = date.at(ns("./from"))
+      to = date.at(ns("./to"))
+      on = date.at(ns("./on"))
+      return date.text unless (from || on || to)
+      return on.text if on
+      ret = "#{from.text}–"
+      ret += to.text if to
+      ret
+    end
+
+    def ns(xpath)
+      xpath.gsub(%r{/([a-zA-z])}, "/xmlns:\\1").
+        gsub(%r{::([a-zA-z])}, "::xmlns:\\1").
+        gsub(%r{\[([a-zA-z][a-z0-9A-Z@/]* ?=)}, "[xmlns:\\1").
+        gsub(%r{\[([a-zA-z][a-z0-9A-Z@/]*\])}, "[xmlns:\\1")
+    end
+
+    def liquid(doc)
+      # unescape HTML escapes in doc
+      doc = doc.split(%r<(\{%|%\})>).each_slice(4).map do |a|
+        a[2] = a[2].gsub("&lt;", "<").gsub("&gt;", ">") if a.size > 2
+        a.join("")
+      end.join("")
+      Liquid::Template.parse(doc)
+    end
+  end
+end

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

@@ -0,0 +1,29 @@
+require_relative "./function/blocks"
+require_relative "./function/cleanup"
+require_relative "./function/inline"
+require_relative "./function/lists"
+require_relative "./function/references"
+require_relative "./function/section"
+require_relative "./function/table"
+require_relative "./function/terms"
+require_relative "./function/to_word_html"
+require_relative "./function/utils"
+require_relative "./function/reqt"
+require_relative "./class_utils"
+
+module IsoDoc
+  class Common
+    include Function::Blocks
+    include Function::Cleanup
+    include Function::Inline
+    include Function::Lists
+    include Function::References
+    include Function::Section
+    include Function::Table
+    include Function::Terms
+    include Function::ToWordHtml
+    include Function::Utils
+
+    extend ::IsoDoc::ClassUtils
+  end
+end

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

@@ -0,0 +1,250 @@
+# frozen_string_literal: true
+require "isodoc/common"
+require "fileutils"
+require "tempfile"
+require_relative "i18n"
+
+module IsoDoc
+  class Convert < ::IsoDoc::Common
+    attr_reader :options
+    attr_accessor :i18n
+
+    # htmlstylesheet: Generic stylesheet for HTML
+    # wordstylesheet: Generic stylesheet for Word
+    # standardsheet: Stylesheet specific to Standard
+    # header: Header file for Word
+    # htmlcoverpage: Cover page for HTML
+    # wordcoverpage: Cover page for Word
+    # htmlintropage: Introductory page for HTML
+    # wordintropage: Introductory page for Word
+    # i18nyaml: YAML file for internationalisation of text
+    # ulstyle: list style in Word CSS for unordered lists
+    # olstyle: list style in Word CSS for ordered lists
+    # bodyfont: font to use for body text
+    # headerfont: font to use for header text
+    # monospace: font to use for monospace text
+    # suppressheadingnumbers: suppress heading numbers for clauses
+    # scripts: Scripts file for HTML
+    # scripts_pdf: Scripts file for PDF
+    # datauriimage: Encode images in HTML output as data URIs
+    def initialize(options)
+      @libdir ||= File.dirname(__FILE__)
+      options.merge!(default_fonts(options)) do |_, old, new|
+        old || new
+      end
+             .merge!(default_file_locations(options)) do |_, old, new|
+        old || new
+      end
+      @options = options
+      @files_to_delete = []
+      @tempfile_cache = []
+      @htmlstylesheet_name = options[:htmlstylesheet]
+      @wordstylesheet_name = options[:wordstylesheet]
+      @standardstylesheet_name = options[:standardstylesheet]
+      @header = options[:header]
+      @htmlcoverpage = options[:htmlcoverpage]
+      @wordcoverpage = options[:wordcoverpage]
+      @htmlintropage = options[:htmlintropage]
+      @wordintropage = options[:wordintropage]
+      @scripts = options[:scripts]
+      @scripts_pdf = options[:scripts_pdf]
+      @i18nyaml = options[:i18nyaml]
+      @ulstyle = options[:ulstyle]
+      @olstyle = options[:olstyle]
+      @datauriimage = options[:datauriimage]
+      @suppressheadingnumbers = options[:suppressheadingnumbers]
+      @break_up_urls_in_tables = options[:break_up_urls_in_tables] == 'true'
+      @termdomain = ''
+      @termexample = false
+      @note = false
+      @sourcecode = false
+      @footnotes = []
+      @comments = []
+      @in_footnote = false
+      @in_comment = false
+      @in_table = false
+      @in_figure = false
+      @seen_footnote = Set.new
+      @c = HTMLEntities.new
+      @openmathdelim = "`"
+      @closemathdelim = "`"
+      @lang = options[:language] || "en"
+      @script = options[:script] || "Latn"
+      @maxwidth = 1200
+      @maxheight = 800
+      @wordToClevels = options[:doctoclevels].to_i
+      @wordToClevels = 2 if @wordToClevels.zero?
+      @htmlToClevels = options[:htmltoclevels].to_i
+      @htmlToClevels = 2 if @htmlToClevels.zero?
+      @bookmarks_allocated = { 'X' => true }
+      @fn_bookmarks = {}
+    end
+
+    # Check if already compiled version(.css) exists,
+    #   if not, return original scss file. During release
+    #   we compile scss into css files in order to not depend on scss
+    def precompiled_style_or_original(stylesheet_path)
+      # Already have compiled stylesheet, use it
+      return stylesheet_path if stylesheet_path.nil? ||
+                                File.extname(stylesheet_path) == '.css'
+
+      basename = File.basename(stylesheet_path, '.*')
+      compiled_path = File.join(File.dirname(stylesheet_path),
+                                "#{basename}.css")
+      return stylesheet_path unless File.file?(compiled_path)
+
+      compiled_path
+    end
+
+    # run this after @meta is populated
+    def populate_css
+      @htmlstylesheet = generate_css(@htmlstylesheet_name, true)
+      @wordstylesheet = generate_css(@wordstylesheet_name, false)
+      @standardstylesheet = generate_css(@standardstylesheet_name, false)
+    end
+
+    def tmpimagedir_suffix
+      '_images'
+    end
+
+    def default_fonts(_options)
+      {
+        bodyfont: 'Arial',
+        headerfont: 'Arial',
+        monospacefont: 'Courier'
+      }
+    end
+
+    # none for this parent gem, but will be populated in child gems 
+    # which have access to stylesheets &c; e.g.
+    # {
+    #      htmlstylesheet: html_doc_path("htmlstyle.scss"),
+    #      htmlcoverpage: html_doc_path("html_rsd_titlepage.html"),
+    #      htmlintropage: html_doc_path("html_rsd_intro.html"),
+    #      scripts: html_doc_path("scripts.html"),
+    #      wordstylesheet: html_doc_path("wordstyle.scss"),
+    #      standardstylesheet: html_doc_path("rsd.scss"),
+    #      header: html_doc_path("header.html"),
+    #      wordcoverpage: html_doc_path("word_rsd_titlepage.html"),
+    #      wordintropage: html_doc_path("word_rsd_intro.html"),
+    #      ulstyle: l3
+    #      olstyle: l2
+    # }
+    def default_file_locations(_options)
+      {}
+    end
+
+    def fonts_options
+      {
+        'bodyfont' => options[:bodyfont] || 'Arial',
+        'headerfont' => options[:headerfont] || 'Arial',
+        'monospacefont' => options[:monospacefont] || 'Courier'
+      }
+    end
+
+    def scss_fontheader
+      b = options[:bodyfont] || 'Arial'
+      h = options[:headerfont] || 'Arial'
+      m = options[:monospacefont] || 'Courier'
+      "$bodyfont: #{b};\n$headerfont: #{h};\n$monospacefont: #{m};\n"
+    end
+
+    def html_doc_path(*file)
+      file.each do |f|
+        ret = File.join(@libdir, File.join('html', f))
+        File.exist?(ret) and return ret
+      end
+      nil
+    end
+
+    def convert_scss(filename, stylesheet)
+      require 'sassc'
+      require 'isodoc/sassc_importer'
+
+      [File.join(Gem.loaded_specs['isodoc'].full_gem_path,
+                 'lib', 'isodoc'),
+                 File.dirname(filename)].each do |name|
+                   SassC.load_paths << name
+                 end
+                 SassC::Engine.new(scss_fontheader + stylesheet, syntax: :scss,
+                                   importer: SasscImporter)
+                   .render
+    end
+
+    def generate_css(filename, stripwordcss)
+      return nil if filename.nil?
+
+      filename = precompiled_style_or_original(filename)
+      stylesheet = File.read(filename, encoding: 'UTF-8')
+      stylesheet = populate_template(stylesheet, :word)
+      stylesheet.gsub!(/(\s|\{)mso-[^:]+:[^;]+;/m, '\\1') if stripwordcss
+      if File.extname(filename) == '.scss'
+        stylesheet = convert_scss(filename, stylesheet)
+      end
+      Tempfile.open([File.basename(filename, '.*'), 'css'],
+                    encoding: 'utf-8') do |f|
+        f.write(stylesheet)
+        f
+      end
+    end
+
+    def convert1(docxml, filename, dir)
+      @xrefs.parse docxml
+      noko do |xml|
+        xml.html **{ lang: @lang.to_s } do |html|
+          html.parent.add_namespace('epub', 'http://www.idpf.org/2007/ops')
+          info docxml, nil
+          populate_css
+          html.head { |head| define_head head, filename, dir }
+          make_body(html, docxml)
+        end
+      end.join("\n")
+    end
+
+    def metadata_init(lang, script, i18n)
+      @meta = Metadata.new(lang, script, i18n)
+    end
+
+    def xref_init(lang, script, _klass, i18n, options)
+      html = HtmlConvert.new(language: @lang, script: @script)
+      @xrefs = Xref.new(lang, script, html, i18n, options)
+    end
+
+    def i18n_init(lang, script, i18nyaml = nil)
+      @i18n = I18n.new(lang, script, i18nyaml || @i18nyaml)
+    end
+
+    def l10n(x, lang = @lang, script = @script)
+      @i18n.l10n(x, lang, script)
+    end
+
+    def convert_init(file, input_filename, debug)
+      docxml = Nokogiri::XML(file)
+      filename, dir = init_file(input_filename, debug)
+      docxml.root.default_namespace = ""
+      lang = docxml&.at(ns("//bibdata/language"))&.text and @lang = lang
+      script = docxml&.at(ns("//bibdata/script"))&.text and @script = script
+      i18n_init(@lang, @script)
+      metadata_init(@lang, @script, @i18n)
+      xref_init(@lang, @script, self, @i18n, {})
+      [docxml, filename, dir]
+    end
+
+    def convert(input_filename, file = nil, debug = false, 
+                output_filename = nil)
+      file = File.read(input_filename, encoding: "utf-8") if file.nil?
+      @openmathdelim, @closemathdelim = extract_delims(file)
+      docxml, filename, dir = convert_init(file, input_filename, debug)
+      result = convert1(docxml, filename, dir)
+      return result if debug
+      output_filename ||= "#{filename}.#{@suffix}"
+      postprocess(result, output_filename, dir)
+      FileUtils.rm_rf dir
+    end
+
+    def middle_clause
+      "//clause[parent::sections][not(@type = 'scope')]"\
+        '[not(descendant::terms)]'
+    end
+  end
+end

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

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

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

@@ -0,0 +1,208 @@
+require_relative "blocks_example_note"
+
+module IsoDoc::Function
+  module Blocks
+    @annotation = false
+
+    def figure_name_parse(node, div, name)
+      return if name.nil? 
+      div.p **{ class: "FigureTitle", style: "text-align:center;" } do |p|
+        name.children.each { |n| parse(n, div) }
+      end
+    end
+
+    def figure_key(out)
+      out.p **{ style: "page-break-after:avoid;"} do |p|
+        p.b { |b| b << @i18n.key }
+      end
+    end
+
+    def figure_attrs(node)
+      attr_code(id: node["id"], class: "figure", style: keep_style(node))
+    end
+
+    def figure_parse(node, out)
+      return pseudocode_parse(node, out) if node["class"] == "pseudocode" ||
+        node["type"] == "pseudocode"
+      @in_figure = true
+      out.div **figure_attrs(node) do |div|
+        node.children.each do |n|
+          figure_key(out) if n.name == "dl"
+          parse(n, div) unless n.name == "name"
+        end
+        figure_name_parse(node, div, node.at(ns("./name")))
+      end
+      @in_figure = false
+    end
+
+    def pseudocode_attrs(node)
+      attr_code(id: node["id"], class: "pseudocode", style: keep_style(node))
+    end
+
+    def pseudocode_parse(node, out)
+      @in_figure = true
+      name = node.at(ns("./name"))
+      out.div **pseudocode_attrs(node) do |div|
+        node.children.each { |n| parse(n, div) unless n.name == "name" }
+        sourcecode_name_parse(node, div, name)
+      end
+      @in_figure = false
+    end
+
+    def sourcecode_name_parse(node, div, name)
+      return if name.nil? 
+      div.p **{ class: "SourceTitle", style: "text-align:center;" } do |p|
+        name.children.each { |n| parse(n, p) }
+      end
+    end
+
+    def admonition_name_parse(_node, div, name)
+      div.p **{ class: "AdmonitionTitle", style: "text-align:center;" } do |p|
+        name.children.each { |n| parse(n, p) }
+      end
+    end
+
+    def sourcecode_attrs(node)
+      attr_code(id: node["id"], class: "Sourcecode", style: keep_style(node))
+    end
+
+    def sourcecode_parse(node, out)
+      name = node.at(ns("./name"))
+      out.p **sourcecode_attrs(node) 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 pre_parse(node, out)
+      out.pre node.text, **attr_code(id: node["id"])
+    end
+
+    def annotation_parse(node, out)
+      @sourcecode = false
+      @annotation = true
+      node.at("./preceding-sibling::*[local-name() = 'annotation']") or
+        out << "<br/>"
+      callout = node.at(ns("//callout[@target='#{node['id']}']"))
+      out << "<br/>&lt;#{callout.text}&gt; "
+      out << node&.children&.text&.strip
+      @annotation = false
+    end
+
+    def admonition_class(node)
+      "Admonition"
+    end
+
+    def admonition_name(node, type)
+      name = node&.at(ns("./name")) and return name
+      name = Nokogiri::XML::Node.new('name', node.document)
+      return unless type && @i18n.admonition[type]
+      name << @i18n.admonition[type]&.upcase
+      name
+    end
+
+    def admonition_attrs(node)
+      attr_code(id: node["id"], class: admonition_class(node),
+                style: keep_style(node))
+    end
+
+    def admonition_parse(node, out)
+      type = node["type"]
+      name = admonition_name(node, type)
+      out.div **admonition_attrs(node) do |t|
+        admonition_name_parse(node, t, name) if name
+        node.children.each { |n| parse(n, t) unless n.name == "name" }
+      end
+    end
+
+    def formula_where(dl, out)
+      return unless dl
+      out.p **{ style: "page-break-after:avoid;"} do |p|
+        p << @i18n.where
+      end
+      parse(dl, out)
+      out.parent.at("./dl")["class"] = "formula_dl"
+    end
+
+    def formula_parse1(node, out)
+      out.div **attr_code(class: "formula") do |div|
+        div.p do |p|
+          parse(node.at(ns("./stem")), div)
+          if lbl = node&.at(ns("./name"))&.text
+            insert_tab(div, 1)
+            div << "(#{lbl})"
+          end
+        end
+      end
+    end
+
+    def formula_attrs(node)
+      attr_code(id: node["id"], style: keep_style(node))
+    end
+
+    def formula_parse(node, out)
+      out.div **formula_attrs(node) do |div|
+        formula_parse1(node, div)
+        formula_where(node.at(ns("./dl")), div)
+        node.children.each do |n|
+          next if %w(stem dl name).include? n.name
+          parse(n, div)
+        end
+      end
+    end
+
+    def para_class(_node)
+      classtype = nil
+      classtype = "MsoCommentText" if in_comment
+      classtype = "Sourcecode" if @annotation
+      classtype
+    end
+
+    def para_attrs(node)
+      attrs = { class: para_class(node), id: node["id"] }
+      s = node["align"].nil? ? "" : "text-align:#{node['align']};"
+      s = "#{s}#{keep_style(node)}"
+      attrs[:style] = s unless s.empty?
+      attrs
+    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) }
+      end
+    end
+
+    def quote_attribution(node, out)
+      author = node.at(ns("./author"))
+      source = node.at(ns("./source"))
+      out.p **{ class: "QuoteAttribution" } do |p|
+        p << "&mdash; #{author.text}" if author
+        p << ", " if author && source
+        eref_parse(source, p) if source
+      end
+    end
+
+    def quote_parse(node, out)
+      attrs = para_attrs(node)
+      attrs[:class] = "Quote"
+      out.div **attr_code(attrs) do |p|
+        node.children.each do |n|
+          parse(n, p) unless ["author", "source"].include? n.name
+        end
+        quote_attribution(node, out)
+      end
+    end
+
+    def passthrough_parse(node, out)
+      return if node["format"] and
+        !(node["format"].split(/,/).include? @format.to_s)
+      out.passthrough node.text
+    end
+  end
+end