metanorma 1.7.6 → 2.0.0

data/lib/metanorma/files_lookup.rb

@@ -1,208 +0,0 @@
-require "isodoc"
-require "htmlentities"
-require "metanorma-utils"
-require_relative "files_lookup_sectionsplit"
-
-module Metanorma
-  # XML collection renderer
-  class FileLookup
-    attr_accessor :files_to_delete, :parent
-
-    # hash for each document in collection of document identifier to:
-    # document reference (fileref or id), type of document reference,
-    # and bibdata entry for that file
-    # @param path [String] path to collection
-    def initialize(path, parent)
-      @c = HTMLEntities.new
-      @files = {}
-      @parent = parent
-      @xml = parent.xml
-      @isodoc = parent.isodoc
-      @path = path
-      @compile = parent.compile
-      @documents = parent.documents
-      @files_to_delete = []
-      read_files
-    end
-
-    def read_files
-      @disambig = Util::DisambigFiles.new
-      @xml.xpath(ns("//docref")).each { |d| read_file(d) }
-    end
-
-    def read_file(docref)
-      ident = docref.at(ns("./identifier"))
-      i = key(@isodoc.docid_prefix(ident["type"], ident.children.to_xml))
-      entry = file_entry(docref, ident.children.to_xml)
-      bibdata_process(entry, i)
-      bibitem_process(entry)
-      @files[i] = entry
-    end
-
-    def bibdata_process(entry, ident)
-      if entry[:attachment]
-        entry[:bibdata] = Metanorma::Document.attachment_bibitem(ident).root
-      else
-        file, _filename = targetfile(entry, read: true)
-        xml = Nokogiri::XML(file, &:huge)
-        add_document_suffix(ident, xml)
-        entry.merge!(anchors: read_anchors(xml), ids: read_ids(xml),
-                     bibdata: xml.at(ns("//bibdata")),
-                     document_suffix: xml.root["document_suffix"])
-      end
-    end
-
-    def bibitem_process(entry)
-      entry[:bibitem] = entry[:bibdata].dup
-      entry[:bibitem].name = "bibitem"
-      entry[:bibitem]["hidden"] = "true"
-      entry[:bibitem].at("./*[local-name() = 'ext']")&.remove
-    end
-
-    # rel_path is the source file address, determined relative to the YAML.
-    # out_path is the destination file address, with any references outside
-    # the working directory (../../...) truncated
-    # identifier is the id with only spaces, no nbsp
-    def file_entry(ref, identifier)
-      out = ref["attachment"] ? ref["fileref"] : File.basename(ref["fileref"])
-      out1 = @disambig.source2dest_filename(out)
-      ret = if ref["fileref"]
-              { type: "fileref", ref: @documents[Util::key identifier].file,
-                rel_path: ref["fileref"],
-                out_path: out1 } # @disambig.source2dest_filename(out) }
-            else { type: "id", ref: ref["id"] }
-            end
-      file_entry_copy(ref, ret)
-      ret.compact
-    end
-
-    def file_entry_copy(ref, ret)
-      %w(attachment sectionsplit index presentation-xml
-         bare-after-first).each do |s|
-        ret[s.gsub("-", "").to_sym] = ref[s] if ref[s]
-      end
-    end
-
-    def add_document_suffix(identifier, doc)
-      document_suffix = Metanorma::Utils::to_ncname(identifier)
-      Metanorma::Utils::anchor_attributes.each do |(tag_name, attribute_name)|
-        Util::add_suffix_to_attributes(doc, document_suffix, tag_name,
-                                       attribute_name, @isodoc)
-      end
-      url_in_css_styles(doc, document_suffix)
-      doc.root["document_suffix"] ||= ""
-      doc.root["document_suffix"] += document_suffix
-    end
-
-    # update relative URLs, url(#...), in CSS in @style attrs (including SVG)
-    def url_in_css_styles(doc, document_suffix)
-      doc.xpath("//*[@style]").each do |s|
-        s["style"] = s["style"]
-          .gsub(%r{url\(#([^)]+)\)}, "url(#\\1_#{document_suffix})")
-      end
-    end
-
-    # return file contents + output filename for each file in the collection,
-    # given a docref entry
-    # @param data [Hash] docref entry
-    # @param read [Boolean] read the file in and return it
-    # @param doc [Boolean] I am a Metanorma document,
-    # so my URL should end with html or pdf or whatever
-    # @param relative [Boolean] Return output path,
-    # formed relative to YAML file, not input path, relative to calling function
-    # @return [Array<String, nil>]
-    def targetfile(data, options)
-      options = { read: false, doc: true, relative: false }.merge(options)
-      path = options[:relative] ? data[:rel_path] : data[:ref]
-      if data[:type] == "fileref"
-        ref_file path, data[:out_path], options[:read], options[:doc]
-      else
-        xml_file data[:id], options[:read]
-      end
-    end
-
-    def targetfile_id(ident, options)
-      targetfile(get(ident), options)
-    end
-
-    def ref_file(ref, out, read, doc)
-      file = File.read(ref, encoding: "utf-8") if read
-      filename = out.dup
-      filename.sub!(/\.xml$/, ".html") if doc
-      [file, filename]
-    end
-
-    def xml_file(id, read)
-      file = @xml.at(ns("//doc-container[@id = '#{id}']")).to_xml if read
-      filename = "#{id}.html"
-      [file, filename]
-    end
-
-    # map locality type and label (e.g. "clause" "1") to id = anchor for
-    # a document
-    # Note: will only key clauses, which have unambiguous reference label in
-    # locality. Notes, examples etc with containers are just plunked against
-    # UUIDs, so that their IDs can at least be registered to be tracked
-    # as existing.
-    def read_anchors(xml)
-      xrefs = @isodoc.xref_init(@lang, @script, @isodoc, @isodoc.i18n,
-                                { locale: @locale })
-      xrefs.parse xml
-      xrefs.get.each_with_object({}) do |(k, v), ret|
-        read_anchors1(k, v, ret)
-      end
-    end
-
-    def read_anchors1(key, val, ret)
-      val[:type] ||= "clause"
-      ret[val[:type]] ||= {}
-      index = if val[:container] || val[:label].nil? || val[:label].empty?
-                UUIDTools::UUID.random_create.to_s
-              else val[:label]
-              end
-      ret[val[:type]][index] = key
-      ret[val[:type]][val[:value]] = key if val[:value]
-    end
-
-    # Also parse all ids in doc (including ones which won't be xref targets)
-    def read_ids(xml)
-      ret = {}
-      xml.traverse do |x|
-        x.text? and next
-        /^semantic__/.match?(x.name) and next
-        x["id"] and ret[x["id"]] = true
-      end
-      ret
-    end
-
-    def key(ident)
-      @c.decode(ident).gsub(/(\p{Zs})+/, " ").sub(/^metanorma-collection /, "")
-    end
-
-    def keys
-      @files.keys
-    end
-
-    def get(ident, attr = nil)
-      if attr then @files[key(ident)][attr]
-      else @files[key(ident)]
-      end
-    end
-
-    def set(ident, attr, value)
-      @files[key(ident)][attr] = value
-    end
-
-    def each
-      @files.each
-    end
-
-    def each_with_index
-      @files.each_with_index
-    end
-
-    def ns(xpath)
-      @isodoc.ns(xpath)
-    end
-  end
-end

data/lib/metanorma/files_lookup_sectionsplit.rb

@@ -1,84 +0,0 @@
-module Metanorma
-  # XML collection renderer
-  class FileLookup
-    def add_section_split
-      ret = @files.keys.each_with_object({}) do |k, m|
-        if @files[k][:sectionsplit] == "true" && !@files[k]["attachment"]
-          process_section_split_instance(k, m)
-          cleanup_section_split_instance(k, m)
-        end
-        m[k] = @files[k]
-      end
-      @files = ret
-    end
-
-    def process_section_split_instance(key, manifest)
-      s, sectionsplit_manifest = sectionsplit(@files[key][:ref],
-                                              @files[key][:out_path], key)
-      s.each_with_index do |f1, i|
-        add_section_split_instance(f1, manifest, key, i)
-      end
-      manifest["#{key}:index.html"] =
-        add_section_split_cover(sectionsplit_manifest, key)
-    end
-
-    def cleanup_section_split_instance(key, manifest)
-      @files_to_delete << manifest["#{key}:index.html"][:ref]
-      #@files[key].delete(:ids).delete(:anchors)
-      @files[key][:indirect_key] = @sectionsplit.key
-    end
-
-    def add_section_split_cover(manifest, ident)
-      cover = @sectionsplit
-        .section_split_cover(manifest, @parent.dir_name_cleanse(ident),
-                             one_doc_collection?)
-      @files[ident][:out_path] = cover
-      { attachment: true, index: false, out_path: cover,
-        ref: File.join(File.dirname(manifest.file), cover) }
-    end
-
-    def one_doc_collection?
-      return false
-      docs = 0
-      @files.each_value do |v|
-        v[:attachment] and next
-        v[:presentationxml] and next
-        docs += 1
-      end
-      docs > 1
-    end
-
-    def add_section_split_instance(file, manifest, key, idx)
-      presfile, newkey, xml =
-        add_section_split_instance_prep(file, key)
-      manifest[newkey] =
-        { parentid: key, presentationxml: true, type: "fileref",
-          rel_path: file[:url], out_path: File.basename(file[:url]),
-          anchors: read_anchors(xml), ids: read_ids(xml),
-          sectionsplit_output: true,
-          bibdata: @files[key][:bibdata], ref: presfile }
-      @files_to_delete << file[:url]
-      manifest[newkey][:bare] = true unless idx.zero?
-    end
-
-    def add_section_split_instance_prep(file, key)
-      presfile = File.join(File.dirname(@files[key][:ref]),
-                           File.basename(file[:url]))
-      newkey = key("#{key.strip} #{file[:title]}")
-      xml = Nokogiri::XML(File.read(presfile), &:huge)
-      [presfile, newkey, xml]
-    end
-
-    def sectionsplit(file, outfile, ident)
-      @sectionsplit = Sectionsplit
-        .new(input: file, base: outfile, dir: File.dirname(file),
-             output: outfile, compile_opts: @parent.compile_options,
-             fileslookup: self, ident: ident, isodoc: @isodoc)
-      coll = @sectionsplit.sectionsplit.sort_by { |f| f[:order] }
-      xml = Nokogiri::XML(File.read(file, encoding: "UTF-8"), &:huge)
-      [coll, @sectionsplit
-        .collection_manifest(File.basename(file), coll, xml, nil,
-                             File.dirname(file))]
-    end
-  end
-end

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 "sectionsplit_links"
-
-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 = xref_preprocess(xml, @fileslookup, @ident)
-      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)
-      xref_process(out, xml, @key)
-      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