metanorma 1.7.7 → 2.0.1

data/lib/metanorma/fontist_utils.rb

@@ -1,122 +0,0 @@
-module Metanorma
-  class FontistUtils
-    class << self
-      private
-
-      def validate_options(options)
-        agree_to_terms = options[:agree_to_terms] || false
-        continue_without_fonts = options[:continue_without_fonts] || false
-        no_progress = options[:no_progress] || false
-
-        [agree_to_terms, continue_without_fonts, no_progress]
-      end
-
-      def validate_install_fonts(processor, options)
-        if options[:no_install_fonts]
-          Util.log("[fontist] Skip font installation because" \
-                   " --no-install-fonts argument passed", :debug)
-          return false
-        elsif !has_custom_fonts?(processor, options, options)
-          Util.log("[fontist] Skip font installation because "\
-                   "fonts_manifest is missing", :debug)
-          return false
-        end
-        true
-      end
-
-      def install_fonts_safe(manifest, agree, continue, no_progress)
-        fontist_install(manifest, agree, no_progress)
-      rescue Fontist::Errors::LicensingError
-        license_error_log(continue)
-      rescue Fontist::Errors::FontError => e
-        log_level = continue ? :warning : :fatal
-        Util.log("[fontist] '#{e.font}' font is not supported. " \
-                 "Please report this issue at github.com/metanorma/metanorma" \
-                 "/issues to report this issue.", log_level)
-      rescue Fontist::Errors::FormulaIndexNotFoundError
-        fintist_update_repo(manifest, agree, continue, no_progress)
-      end
-
-      def fontist_install(manifest, agree, no_progress)
-        if agree
-          no_license_log
-        else
-          Fontist.log_level = :info
-        end
-
-        Fontist::Manifest::Install.from_hash(
-          manifest,
-          confirmation: agree ? "yes" : "no",
-          no_progress: no_progress,
-        )
-      end
-
-      def license_error_log(continue)
-        if continue
-          Util.log(
-            "[fontist] Processing will continue without fonts installed",
-            :debug,
-          )
-        else
-          Util.log("[fontist] Aborting without proper fonts installed," \
-                   " make sure that you have set option --agree-to-terms",
-                   :fatal)
-        end
-      end
-
-      def no_license_log
-        Util.log(
-          "[fontist] Font licenses are not shown with --agree-to-terms option.",
-          :info,
-        )
-      end
-
-      def fintist_update_repo(manifest, agree, continue, no_progress)
-        if @@updated_formulas_repo
-          Util.log(
-            "[fontist] Bug: formula index not found after 'fontist update'",
-            :fatal,
-          )
-        end
-        Util.log("[fontist] Missing formula index. Fetching it...", :debug)
-        Fontist::Formula.update_formulas_repo
-        @@updated_formulas_repo = true
-        install_fonts_safe(manifest, agree, continue, no_progress)
-      end
-    end
-
-    def self.install_fonts(processor, options)
-      return unless validate_install_fonts(processor, options)
-
-      @@updated_formulas_repo = false
-      manifest = processor.fonts_manifest.dup
-      append_source_fonts(manifest, options)
-      agree_to_terms, can_without_fonts, no_progress = validate_options(options)
-
-      install_fonts_safe(
-        manifest,
-        agree_to_terms,
-        can_without_fonts,
-        no_progress,
-      )
-    end
-
-    def self.has_custom_fonts?(processor, options, source_attributes)
-      !options[:no_install_fonts] \
-        && processor.respond_to?(:fonts_manifest) \
-        && !processor.fonts_manifest.nil? \
-        || source_attributes[:fonts]
-    end
-
-    def self.location_manifest(processor, source_attributes)
-      Fontist::Manifest::Locations.from_hash(
-        append_source_fonts(processor.fonts_manifest.dup, source_attributes),
-      )
-    end
-
-    def self.append_source_fonts(manifest, source_attributes)
-      source_attributes[:fonts]&.split(";")&.each { |f| manifest[f] = nil }
-      manifest
-    end
-  end
-end

data/lib/metanorma/sectionsplit.rb

@@ -1,216 +0,0 @@
-require "yaml"
-require_relative "util"
-require_relative "collection_xref_process"
-
-module Metanorma
-  class Sectionsplit
-    attr_accessor :filecache, :key
-
-    def initialize(opts)
-      @input_filename = opts[:input]
-      @base = opts[:base]
-      @output_filename = opts[:output]
-      @xml = opts[:xml]
-      @dir = opts[:dir]
-      @compile_opts = opts[:compile_opts] || {}
-      @fileslookup = opts[:fileslookup]
-      @ident = opts[:ident]
-      @isodoc = opts[:isodoc]
-    end
-
-    def ns(xpath)
-      @isodoc.ns(xpath)
-    end
-
-    def build_collection
-      collection_setup(@base, @dir)
-      files = sectionsplit # (@input_filename, @base, @dir, @compile_opts)
-      input_xml = Nokogiri::XML(File.read(@input_filename,
-                                          encoding: "UTF-8"), &:huge)
-      collection_manifest(@base, files, input_xml, @xml, @dir).render(
-        { format: %i(html), output_folder: "#{@output_filename}_collection",
-          coverpage: File.join(@dir, "cover.html") }.merge(@compile_opts),
-      )
-    end
-
-    def collection_manifest(filename, files, origxml, _presxml, dir)
-      File.open(File.join(dir, "#{filename}.html.yaml"), "w:UTF-8") do |f|
-        f.write(collectionyaml(files, origxml))
-      end
-      Metanorma::Collection.parse File.join(dir, "#{filename}.html.yaml")
-    end
-
-    def collection_setup(filename, dir)
-      FileUtils.mkdir_p "#{filename}_collection" if filename
-      FileUtils.mkdir_p dir
-      File.open(File.join(dir, "cover.html"), "w:UTF-8") do |f|
-        f.write(coll_cover)
-      end
-    end
-
-    def coll_cover
-      <<~COVER
-        <html><head><meta charset="UTF-8"/></head><body>
-              <h1>{{ doctitle }}</h1>
-              <h2>{{ docnumber }}</h2>
-              <nav>{{ navigation }}</nav>
-            </body></html>
-      COVER
-    end
-
-    SPLITSECTIONS =
-      [["//preface/*", "preface"], ["//sections/*", "sections"],
-       ["//annex", nil],
-       ["//bibliography/*[not(@hidden = 'true')]", "bibliography"],
-       ["//indexsect", nil], ["//colophon", nil]].freeze
-
-    # Input XML is Semantic
-    # def sectionsplit(filename, basename, dir, compile_options, fileslookup = nil, ident = nil)
-    def sectionsplit
-      xml = sectionsplit_prep(File.read(@input_filename), @base, @dir)
-      @key = Metanorma::XrefProcess::xref_preprocess(xml, @isodoc)
-      SPLITSECTIONS.each_with_object([]) do |n, ret|
-        conflate_floatingtitles(xml.xpath(ns(n[0]))).each do |s|
-          ret << sectionfile(xml, emptydoc(xml), "#{@base}.#{ret.size}", s,
-                             n[1])
-        end
-      end
-    end
-
-    def block?(node)
-      %w(p table formula admonition ol ul dl figure quote sourcecode example
-         pre note pagebrreak hr bookmark requirement recommendation permission
-         svgmap inputform toc passthrough review imagemap).include?(node.name)
-    end
-
-    def conflate_floatingtitles(nodes)
-      holdover = false
-      nodes.each_with_object([]) do |x, m|
-        if holdover then m.last << x
-        else m << [x]
-        end
-        holdover = block?(x)
-      end
-    end
-
-    def sectionsplit_prep(file, filename, dir)
-      @splitdir = dir
-      xml1filename, type = sectionsplit_preprocess_semxml(file, filename)
-      Compile.new.compile(
-        xml1filename,
-        { format: :asciidoc, extension_keys: [:presentation], type: type }
-       .merge(@compile_opts),
-      )
-      Nokogiri::XML(File.read(xml1filename.sub(/\.xml$/, ".presentation.xml"),
-                              encoding: "utf-8"), &:huge)
-    end
-
-    def sectionsplit_preprocess_semxml(file, filename)
-      xml = Nokogiri::XML(file, &:huge)
-      type = xml.root.name.sub("-standard", "").to_sym
-      sectionsplit_update_xrefs(xml)
-      xml1 = sectionsplit_write_semxml(filename, xml)
-      @filecache ||= []
-      @filecache << xml1
-      [xml1.path, type]
-    end
-
-    def sectionsplit_update_xrefs(xml)
-      if c = @fileslookup&.parent
-        n = c.nested
-        c.nested = true # so unresolved erefs are not deleted
-        c.update_xrefs(xml, @ident, {})
-        c.nested = n
-      end
-    end
-
-    def sectionsplit_write_semxml(filename, xml)
-      Tempfile.open([filename, ".xml"], encoding: "utf-8") do |f|
-        # f.write(@isodoc.to_xml(svg_preprocess(xml)))
-        f.write(@isodoc.to_xml(xml))
-        f
-      end
-    end
-
-    def emptydoc(xml)
-      out = xml.dup
-      out.xpath(
-        ns("//preface | //sections | //annex | //bibliography/clause | " \
-           "//bibliography/references[not(@hidden = 'true')] | //indexsect | " \
-           "//colophon"),
-      ).each(&:remove)
-      out
-    end
-
-    def sectionfile(fulldoc, xml, file, chunks, parentnode)
-      fname = create_sectionfile(fulldoc, xml.dup, file, chunks, parentnode)
-      { order: chunks.last["displayorder"].to_i, url: fname,
-        title: titlerender(chunks.last) }
-    end
-
-    def create_sectionfile(xml, out, file, chunks, parentnode)
-      ins = out.at(ns("//metanorma-extension")) || out.at(ns("//bibdata"))
-      sectionfile_insert(ins, chunks, parentnode)
-      Metanorma::XrefProcess::xref_process(out, xml, @key, @ident, @isodoc)
-      outname = "#{file}.xml"
-      File.open(File.join(@splitdir, outname), "w:UTF-8") do |f|
-        f.write(out)
-      end
-      outname
-    end
-
-    def sectionfile_insert(ins, chunks, parentnode)
-      if parentnode
-        ins.next = "<#{parentnode}/>"
-        chunks.each { |c| ins.next.add_child(c.dup) }
-      else chunks.each { |c| ins.next = c.dup }
-      end
-    end
-
-    def titlerender(section)
-      title = section.at(ns("./title")) or return "[Untitled]"
-      t = title.dup
-      t.xpath(ns(".//tab | .//br")).each { |x| x.replace(" ") }
-      t.xpath(ns(".//strong")).each { |x| x.replace(x.children) }
-      t.children.to_xml
-    end
-
-    def collectionyaml(files, xml)
-      ret = {
-        directives: ["presentation-xml", "bare-after-first"],
-        bibdata: {
-          title: {
-            type: "title-main", language: @lang,
-            content: xml.at(ns("//bibdata/title")).text
-          },
-          type: "collection",
-          docid: {
-            type: xml.at(ns("//bibdata/docidentifier/@type")).text,
-            id: xml.at(ns("//bibdata/docidentifier")).text,
-          },
-        },
-        manifest: {
-          level: "collection", title: "Collection",
-          docref: files.sort_by { |f| f[:order] }.each.map do |f|
-            { fileref: f[:url], identifier: f[:title] }
-          end
-        },
-      }
-      Util::recursive_string_keys(ret).to_yaml
-    end
-
-    def section_split_cover(col, ident, one_doc_coll)
-      dir = File.dirname(col.file)
-      collection_setup(nil, dir)
-      CollectionRenderer.new(col, dir,
-                             output_folder: "#{ident}_collection",
-                             format: %i(html),
-                             coverpage: File.join(dir, "cover.html")).coverpage
-      #filename = one_doc_coll ? "#{ident}_index.html" : "index.html"
-      filename = "#{ident}_index.html"
-      FileUtils.mv "#{ident}_collection/index.html", File.join(dir, filename)
-      FileUtils.rm_rf "#{ident}_collection"
-      filename
-    end
-  end
-end

data/lib/metanorma/util.rb

@@ -1,127 +0,0 @@
-module Metanorma
-  module Util
-    def self.log(message, type = :info)
-      log_types = Metanorma.configuration.logs.map(&:to_s) || []
-
-      if log_types.include?(type.to_s)
-        puts(message)
-      end
-
-      if type == :fatal
-        exit(1)
-      end
-    end
-
-    # dependency ordering
-    def self.sort_extensions_execution_ord(ext)
-      case ext
-      when :xml then 0
-      when :rxl then 1
-      when :presentation then 2
-      else
-        99
-      end
-    end
-
-    def self.sort_extensions_execution(ext)
-      ext.sort do |a, b|
-        sort_extensions_execution_ord(a) <=> sort_extensions_execution_ord(b)
-      end
-    end
-
-    def self.recursive_string_keys(hash)
-      case hash
-      when Hash then hash.map { |k, v| [k.to_s, recursive_string_keys(v)] }.to_h
-      when Enumerable then hash.map { |v| recursive_string_keys(v) }
-      else
-        hash
-      end
-    end
-
-    def self.gather_bibitems(xml)
-      xml.xpath("//xmlns:bibitem[@id]").each_with_object({}) do |b, m|
-        if m[b["id"]]
-          b.remove
-          next # we can't update duplicate bibitem, processing updates wrong one
-        else
-          m[b["id"]] = b
-        end
-      end
-    end
-
-    def self.gather_bibitemids(xml)
-      xml.xpath("//*[@bibitemid]").each_with_object({}) do |e, m|
-        /^semantic__/.match?(e.name) and next
-        m[e["bibitemid"]] ||= []
-        m[e["bibitemid"]] << e
-      end
-    end
-
-    def self.gather_citeases(xml)
-      xml.xpath("//*[@citeas]").each_with_object({}) do |e, m|
-        /^semantic__/.match?(e.name) and next
-        m[e["citeas"]] ||= []
-        m[e["citeas"]] << e
-      end
-    end
-
-    def self.add_suffix_to_attributes(doc, suffix, tag_name, attr_name, isodoc)
-      (suffix.nil? || suffix.empty?) and return
-      doc.xpath(isodoc.ns("//#{tag_name}[@#{attr_name}]")).each do |elem|
-        a = elem.attributes[attr_name].value
-        /_#{suffix}$/.match?(a) or
-          elem.attributes[attr_name].value = "#{a}_#{suffix}"
-      end
-    end
-
-    def self.hash_key_detect(directives, key, variable)
-      c = directives.detect { |x| x.is_a?(Hash) && x.has_key?(key) } or
-        return variable
-      c[key]
-    end
-
-    def self.rel_path_resolve(dir, path)
-      path.nil? and return path
-      path.empty? and return path
-      p = Pathname.new(path)
-      p.absolute? ? path : File.join(dir, path)
-    end
-
-    def self.key(ident)
-      @c ||= HTMLEntities.new
-      @c.decode(ident).gsub(/(\p{Zs})+/, " ")
-    end
-
-    class DisambigFiles
-      def initialize
-        @seen_filenames = []
-      end
-
-      def strip_root(name)
-        name.sub(%r{^(\./)?(\.\./)+}, "")
-      end
-
-      def source2dest_filename(name, disambig = true)
-        n = strip_root(name)
-        dir = File.dirname(n)
-        base = File.basename(n)
-        if disambig && @seen_filenames.include?(base)
-          base = disambiguate_filename(base)
-        end
-        @seen_filenames << base
-        dir == "." ? base : File.join(dir, base)
-      end
-
-      def disambiguate_filename(base)
-        m = /^(?<start>.+\.)(?!0)(?<num>\d+)\.(?<suff>[^.]*)$/.match(base) ||
-          /^(?<start>.+\.)(?<suff>[^.]*)/.match(base) ||
-          /^(?<start>.+)$/.match(base)
-        i = m.names.include?("num") ? m["num"].to_i + 1 : 1
-        while @seen_filenames.include? base = "#{m['start']}#{i}.#{m['suff']}"
-          i += 1
-        end
-        base
-      end
-    end
-  end
-end

data/lib/metanorma/worker_pool.rb

@@ -1,29 +0,0 @@
-module Metanorma
-  class WorkersPool
-    def initialize(workers)
-      @workers = workers
-      @queue = SizedQueue.new(@workers)
-      @threads = Array.new(@workers) do
-        Thread.new do
-          catch(:exit) do
-            loop do
-              job, args = @queue.pop
-              job.call *args
-            end
-          end
-        end
-      end
-    end
-
-    def schedule(*args, &block)
-      @queue << [block, args]
-    end
-
-    def shutdown
-      @workers.times do
-        schedule { throw :exit }
-      end
-      @threads.map(&:join)
-    end
-  end
-end