RubyGems - metanorma-cli - Versions diffs - 1.3.3.1 → 1.3.4 - Mend

metanorma-cli 1.3.3.1 → 1.3.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (950) hide show

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

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+module IsoDoc::Function
+  module Utils
+    def date_range(date)
+      self.class.date_range(date)
+    end
+    def ns(xpath)
+      self.class.ns(xpath)
+    end
+    def insert_tab(out, n)
+      tab = %w(Hans Hant).include?(@script) ? "&#x3000;" : "&nbsp; "
+      [1..n].each { out << tab }
+    end
+    # add namespaces for Word fragments
+    NOKOHEAD = <<~HERE
+      <!DOCTYPE html SYSTEM
+      "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
+      <html xmlns="http://www.w3.org/1999/xhtml">
+      <head> <title></title> <meta charset="UTF-8" /> </head>
+      <body> </body> </html>
+    HERE
+    # block for processing XML document fragments as XHTML,
+    # to allow for HTMLentities
+    def noko(&block)
+      doc = ::Nokogiri::XML.parse(NOKOHEAD)
+      fragment = doc.fragment('')
+      ::Nokogiri::XML::Builder.with fragment, &block
+      fragment.to_xml(encoding: 'US-ASCII').lines.map do |l|
+        l.gsub(/\s*\n/, '')
+      end
+    end
+    def attr_code(attributes)
+      attributes = attributes.reject { |_, val| val.nil? }.map
+      attributes.map do |k, v|
+        [k, v.is_a?(String) ? HTMLEntities.new.decode(v) : v]
+      end.to_h
+    end
+    DOCTYPE_HDR = '<!DOCTYPE html SYSTEM '\
+      '"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">'
+    def to_xhtml(xml)
+      xml.gsub!(/<\?xml[^>]*>/, '')
+      /<!DOCTYPE /.match(xml) || (xml = DOCTYPE_HDR + xml)
+      xml = xml.split(/(\&[^ \r\n\t#;]+;)/).map do |t|
+        /^(\&[^ \t\r\n#;]+;)/.match?(t) ?
+          HTMLEntities.new.encode(HTMLEntities.new.decode(t), :hexadecimal) : t
+      end.join('')
+      begin
+        Nokogiri::XML.parse(xml, &:strict)
+      rescue Nokogiri::XML::SyntaxError => e
+        File.open("#{@filename}.#{@format}.err", 'w:UTF-8') { |f| f.write xml }
+        abort "Malformed Output XML for #{@format}: #{e} (see #{@filename}.#{@format}.err)"
+      end
+    end
+    def to_xhtml_fragment(xml)
+      doc = ::Nokogiri::XML.parse(NOKOHEAD)
+      fragment = doc.fragment(xml)
+      fragment
+    end
+    def from_xhtml(xml)
+      xml.to_xml.sub(%r{ xmlns="http://www.w3.org/1999/xhtml"}, '')
+    end
+    CLAUSE_ANCESTOR =
+      ".//ancestor::*[local-name() = 'annex' or "\
+      "local-name() = 'acknowledgements' or local-name() = 'term' or "\
+      "local-name() = 'appendix' or local-name() = 'foreword' or "\
+      "local-name() = 'introduction' or local-name() = 'terms' or "\
+      "local-name() = 'clause' or local-name() = 'references']/@id"
+    def get_clause_id(node)
+      clause = node.xpath(CLAUSE_ANCESTOR)
+      clause&.last&.text || nil
+    end
+    NOTE_CONTAINER_ANCESTOR =
+      ".//ancestor::*[local-name() = 'annex' or "\
+      "local-name() = 'foreword' or local-name() = 'appendix' or "\
+      "local-name() = 'introduction' or local-name() = 'terms' or "\
+      "local-name() = 'acknowledgements' or local-name() = 'term' or "\
+      "local-name() = 'clause' or local-name() = 'references' or "\
+      "local-name() = 'figure' or local-name() = 'formula' or "\
+      "local-name() = 'table' or local-name() = 'example']/@id"
+    def get_note_container_id(node)
+      container = node.xpath(NOTE_CONTAINER_ANCESTOR)
+      container&.last&.text || nil
+    end
+    def sentence_join(array)
+      return '' if array.nil? || array.empty?
+      if array.length == 1 then array[0]
+      else
+        @i18n.l10n("#{array[0..-2].join(', ')} "\
+                   "#{@i18n.and} #{array.last}",
+                                     @lang, @script)
+      end
+    end
+    # avoid `; avoid {{ (Liquid Templates); avoid [[ (Javascript)
+    def extract_delims(text)
+      @openmathdelim = '(#('
+      @closemathdelim = ')#)'
+      while text.include?(@openmathdelim) || text.include?(@closemathdelim)
+        @openmathdelim += '('
+        @closemathdelim += ')'
+      end
+      [@openmathdelim, @closemathdelim]
+    end
+    def header_strip(h)
+      h = h.to_s.gsub(%r{<br\s*/>}, ' ').gsub(/<\/?h[123456][^>]*>/, '')
+           .gsub(/<\/?b[^>]*>/, '')
+      h1 = to_xhtml_fragment(h.dup)
+      h1.traverse do |x|
+        x.replace(' ') if x.name == 'span' && /mso-tab-count/.match(x['style'])
+        x.remove if x.name == 'span' && x['class'] == 'MsoCommentReference'
+        x.remove if x.name == 'a' && x['class'] == 'FootnoteRef'
+        x.remove if x.name == 'span' && /mso-bookmark/.match(x['style'])
+        x.replace(x.children) if x.name == 'a'
+      end
+      from_xhtml(h1)
+    end
+    def liquid(doc)
+      self.class.liquid(doc)
+    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
+    def empty2nil(v)
+      return nil if !v.nil? && v.is_a?(String) && v.empty?
+      v
+    end
+    def populate_template(docxml, _format = nil)
+      meta = @meta
+             .get
+             .merge(@labels || {})
+             .merge(@meta.labels || {})
+             .merge(fonts_options || {})
+      template = liquid(docxml)
+      template.render(meta.map { |k, v| [k.to_s, empty2nil(v)] }.to_h)
+              .gsub('&lt;', '&#x3c;').gsub('&gt;', '&#x3e;').gsub('&amp;', '&#x26;')
+    end
+    def save_dataimage(uri, _relative_dir = true)
+      %r{^data:image/(?<imgtype>[^;]+);base64,(?<imgdata>.+)$} =~ uri
+      imgtype.sub!(/\+[a-z0-9]+$/, '') # svg+xml
+      imgtype = 'png' unless /^[a-z0-9]+$/.match imgtype
+      Tempfile.open(['image', ".#{imgtype}"]) do |f|
+        f.binmode
+        f.write(Base64.strict_decode64(imgdata))
+        @tempfile_cache << f # persist to the end
+        f.path
+      end
+    end
+    def image_localfile(i)
+      if /^data:image/.match? i['src']
+        save_dataimage(i['src'], false)
+      elsif %r{^([A-Z]:)?/}.match? i['src']
+        i['src']
+      else
+        File.join(@localdir, i['src'])
+      end
+    end
+    def labelled_ancestor(node)
+      !node.ancestors('example, requirement, recommendation, permission, '\
+                             'table, figure, sourcecode').empty?
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/gem_tasks.rb ADDED

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+require 'sassc'
+require 'isodoc/sassc_importer'
+require 'rake/clean'
+module IsoDoc
+  module GemTasks
+    extend Rake::DSL if defined? Rake::DSL
+    module_function
+    def install
+      rule '.css' => [proc { |tn| tn.sub(/\.css$/, '.scss') }] do |current_task|
+        begin
+          puts(current_task)
+          compile_scss_task(current_task)
+        rescue StandardError => e
+          notify_borken_compilation(e, current_task)
+        end
+      end
+      scss_files = Rake::FileList['lib/**/*.scss']
+      source_files = scss_files.ext('.css')
+      task :comment_out_liquid do
+        process_css_files(scss_files) do |file_name|
+          comment_out_liquid(File.read(file_name, encoding: 'UTF-8'))
+        end
+      end
+      task build_scss: [:comment_out_liquid].push(*source_files) do
+        process_css_files(scss_files) do |file_name|
+          uncomment_out_liquid(File.read(file_name, encoding: 'UTF-8'))
+        end
+        git_cache_compiled_files && puts('Built scss!')
+      end
+      Rake::Task['build'].enhance [:build_scss] do
+        git_rm_compiled_files
+        Rake::Task[:clean].invoke
+      end
+    end
+    def notify_borken_compilation(error, current_task)
+      puts("Cannot compile #{current_task} because of #{error.message}")
+      puts('continue anyway[y|n]?')
+      answer = STDIN.gets.strip
+      if %w[y yes].include?(answer.strip.downcase)
+        puts("Cannot compile #{current_task} because of #{error.message}")
+      else
+        exit(0)
+      end
+    end
+    def git_cache_compiled_files
+      CLEAN.each do |css_file|
+        sh "git add #{css_file}"
+      end
+    end
+    def git_rm_compiled_files
+      CLEAN.each do |css_file|
+        sh "git rm --cached #{css_file}"
+      end
+    end
+    def process_css_files(scss_files)
+      scss_files.each do |file_name|
+        result = yield(file_name)
+        File.open(file_name, 'w', encoding: 'UTF-8') do |file|
+          file.puts(result)
+        end
+      end
+    end
+    def comment_out_liquid(text)
+      text.split("\n").map do |line|
+        if line.match?(/{({|%).+(}|%)}/)
+          "/* LIQUID_COMMENT#{line}LIQUID_COMMENT */"
+        else
+          line
+        end
+      end
+          .join("\n")
+    end
+    def uncomment_out_liquid(text)
+      text
+        .gsub('/* LIQUID_COMMENT', '')
+        .gsub('LIQUID_COMMENT */', '')
+        .gsub('"{{', '{{').gsub('}}"', '}}')
+    end
+    def fonts_placeholder
+      <<~TEXT
+        $bodyfont: '{{bodyfont}}';
+        $headerfont: '{{headerfont}}';
+        $monospacefont: '{{monospacefont}}';
+      TEXT
+    end
+    def compile_scss(filename)
+      require 'sassc'
+      isodoc_path = if Gem.loaded_specs['isodoc']
+                      File.join(Gem.loaded_specs['isodoc'].full_gem_path, 'lib', 'isodoc')
+                    else
+                      File.join('lib', 'isodoc')
+                    end
+      [isodoc_path,
+       File.dirname(filename)].each do |name|
+        SassC.load_paths << name
+      end
+      sheet_content = File.read(filename, encoding: 'UTF-8')
+      SassC::Engine.new(fonts_placeholder + sheet_content,
+                        syntax: :scss,
+                        importer: SasscImporter)
+                   .render
+    end
+    def compile_scss_task(current_task)
+      filename = current_task.source
+      basename = File.basename(filename, '.*')
+      compiled_path = File.join(File.dirname(filename), "#{basename}.css")
+      content = uncomment_out_liquid(compile_scss(filename))
+      File.open(compiled_path, 'w:UTF-8') do |f|
+        f.write(content)
+      end
+      CLEAN << compiled_path
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/headlesshtml_convert.rb ADDED

@@ -0,0 +1,45 @@
+require_relative "html_function/comments.rb"
+require_relative "html_function/footnotes.rb"
+require_relative "html_function/html.rb"
+require "fileutils"
+module IsoDoc
+  class HeadlessHtmlConvert < ::IsoDoc::Convert
+    include HtmlFunction::Comments
+    include HtmlFunction::Footnotes
+    include HtmlFunction::Html
+    def tmpimagedir_suffix
+      "_headlessimages"
+    end
+    def initialize(options)
+      @format = :html
+      @suffix = "headless.html"
+      super
+    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
+      postprocess(result, filename + ".tmp.html", dir)
+      FileUtils.rm_rf dir
+      strip_head(filename + ".tmp.html", output_filename || "#{filename}.#{@suffix}")
+      FileUtils.rm_rf ["#{filename}.tmp.html", tmpimagedir]
+    end
+    def strip_head(input, output)
+      file = File.read(input, encoding: "utf-8")
+      doc = Nokogiri::XML(file)
+      doc.xpath("//head").each { |x| x.remove }
+      doc.xpath("//html").each { |x| x.name = "div" }
+      body = doc.at("//body")
+      body.replace(body.children)
+      File.open(output, "w") { |f| f.write(doc.to_xml) }
+    end
+  end
+end

data/gems/ruby/2.6.0/gems/isodoc-1.2.1/lib/isodoc/html_convert.rb ADDED

@@ -0,0 +1,30 @@
+require_relative "html_function/comments.rb"
+require_relative "html_function/footnotes.rb"
+require_relative "html_function/html.rb"
+require_relative "html_function/postprocess.rb"
+module IsoDoc
+  class HtmlConvert < ::IsoDoc::Convert
+    include HtmlFunction::Comments
+    include HtmlFunction::Footnotes
+    include HtmlFunction::Html
+    def tmpimagedir_suffix
+      "_htmlimages"
+    end
+    def initialize(options)
+      @format = :html
+      @suffix = "html"
+      super
+    end
+    def convert(filename, file = nil, debug = false, output_filename = nil)
+      ret = super
+      Dir.exists?(tmpimagedir) and Dir["#{tmpimagedir}/*"].empty? and
+        FileUtils.rm_r tmpimagedir
+      ret
+    end
+  end
+end

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

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

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

@@ -0,0 +1,144 @@
+module IsoDoc::HtmlFunction
+  module Comments
+    def in_comment
+      @in_comment
+    end
+    def comments(div)
+=begin
+      return if @comments.empty?
+      div.div **{ style: "mso-element:comment-list" } do |div1|
+        @comments.each { |fn| div1.parent << fn }
+      end
+=end
+    end
+    def review_note_parse(node, out)
+=begin
+      fn = @comments.length + 1
+      make_comment_link(out, fn, node)
+      @in_comment = true
+      @comments << make_comment_text(node, fn)
+      @in_comment = false
+=end
+    end
+    def comment_link_attrs(fn, node)
+      { style: "MsoCommentReference", target: fn,
+        class: "commentLink", from: node["from"],
+        to: node["to"] }
+    end
+    # add in from and to links to move the comment into place
+    def make_comment_link(out, fn, node)
+      out.span(**comment_link_attrs(fn, node)) do |s1|
+          s1.a **{ style: "mso-comment-reference:SMC_#{fn};"\
+                   "mso-comment-date:#{node['date'].gsub(/[-:Z]/, '')}" }
+        end
+    end
+    def make_comment_target(out)
+      out.span **{ style: "MsoCommentReference" } do |s1|
+          s1.span **{ style: "mso-special-character:comment" }
+        end
+    end
+    def make_comment_text(node, fn)
+      noko do |xml|
+        xml.div **{ style: "mso-element:comment", id: fn } do |div|
+          div.span **{ style: %{mso-comment-author:"#{node['reviewer']}"} }
+          make_comment_target(div)
+          node.children.each { |n| parse(n, div) }
+        end
+      end.join("\n")
+    end
+    def comment_cleanup(docxml)
+=begin
+      move_comment_link_to_from(docxml)
+      reorder_comments_by_comment_link(docxml)
+      embed_comment_in_comment_list(docxml)
+=end
+    end
+    COMMENT_IN_COMMENT_LIST =
+      '//div[@style="mso-element:comment-list"]//'\
+      'span[@style="MsoCommentReference"]'.freeze
+    def embed_comment_in_comment_list(docxml)
+      docxml.xpath(COMMENT_IN_COMMENT_LIST).each do |x|
+        n = x.next_element
+        n&.children&.first&.add_previous_sibling(x.remove)
+      end
+      docxml
+    end
+    def move_comment_link_to_from1(x, fromlink)
+      x.remove
+      link = x.at(".//a")
+      fromlink.replace(x)
+      link.children = fromlink
+    end
+    def comment_attributes(docxml, x)
+      fromlink = docxml.at("//*[@id='#{x['from']}']")
+      return(nil) if fromlink.nil?
+      tolink = docxml.at("//*[@id='#{x['to']}']") || fromlink
+      target = docxml.at("//*[@id='#{x['target']}']")
+      { from: fromlink, to: tolink, target: target }
+    end
+    def wrap_comment_cont(from, target)
+      s = from.replace("<span style='mso-comment-continuation:#{target}'>")
+      s.first.children = from
+    end
+    def skip_comment_wrap(from)
+      from["style"] != "mso-special-character:comment"
+    end
+    def insert_comment_cont(from, to, target)
+      # includes_to = from.at(".//*[@id='#{to}']")
+      while !from.nil? && from["id"] != to
+        following = from.xpath("./following::*")
+        (from = following.shift) && incl_to = from.at(".//*[@id='#{to}']")
+        while !incl_to.nil? && !from.nil? && skip_comment_wrap(from)
+          (from = following.shift) && incl_to = from.at(".//*[@id='#{to}']")
+        end
+        wrap_comment_cont(from, target) if !from.nil?
+      end
+    end
+    def move_comment_link_to_from(docxml)
+      docxml.xpath('//span[@style="MsoCommentReference"][@from]').each do |x|
+        attrs = comment_attributes(docxml, x) || next
+        move_comment_link_to_from1(x, attrs[:from])
+        insert_comment_cont(attrs[:from], x["to"], x["target"])
+      end
+    end
+    def get_comments_from_text(docxml, link_order)
+      comments = []
+      docxml.xpath("//div[@style='mso-element:comment']").each do |c|
+        next unless c["id"] && !link_order[c["id"]].nil?
+        comments << { text: c.remove.to_s, id: c["id"] }
+      end
+      comments.sort! { |a, b| link_order[a[:id]] <=> link_order[b[:id]] }
+      # comments
+    end
+    COMMENT_TARGET_XREFS =
+      "//span[@style='mso-special-character:comment']/@target".freeze
+    def reorder_comments_by_comment_link(docxml)
+      link_order = {}
+      docxml.xpath(COMMENT_TARGET_XREFS).each_with_index do |target, i|
+        link_order[target.value] = i
+      end
+      comments = get_comments_from_text(docxml, link_order)
+      list = docxml.at("//*[@style='mso-element:comment-list']") || return
+      list.children = comments.map { |c| c[:text] }.join("\n")
+    end
+  end
+end