metanorma 1.6.2 → 1.6.3

data/lib/metanorma/collection_fileprocess.rb

@@ -7,172 +7,10 @@ require_relative "collection_fileparse"
 module Metanorma
   # XML collection renderer
   class CollectionRenderer
-=begin
-    # 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
-    # @return [Hash{String=>Hash}]
-    def read_files(path) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      files = {}
-      @xml.xpath(ns("//docref")).each do |d|
-        orig_id = d.at(ns("./identifier"))
-        identifier = @c.decode(@isodoc
-                  .docid_prefix(orig_id["type"], orig_id.children.to_xml))
-        files[identifier] = file_entry(d, orig_id.children.to_xml, path)
-        if files[identifier][:attachment]
-          files[identifier][:bibdata] = Metanorma::Document
-            .attachment_bibitem(identifier).root
-        else
-          file, _filename = targetfile(files[identifier], read: true)
-          xml = Nokogiri::XML(file)
-          add_document_suffix(identifier, xml)
-          files[identifier][:anchors] = read_anchors(xml)
-          files[identifier][:bibdata] = xml.at(ns("//bibdata"))
-        end
-        files[identifier][:bibitem] = files[identifier][:bibdata].dup
-        files[identifier][:bibitem].name = "bibitem"
-        files[identifier][:bibitem]["hidden"] = "true"
-        files[identifier][:bibitem]&.at("./*[local-name() = 'ext']")&.remove
-      end
-      add_section_split(files)
-    end
-
-    def add_section_split(files)
-      files.keys.each_with_object({}) do |k, m|
-        if files[k][:sectionsplit] == "true" && !files[k]["attachment"]
-          s, manifest = sectionsplit(files[k][:ref])
-          s.each_with_index do |f1, i|
-            add_section_split_instance(f1, m, k, i, files)
-          end
-          m["#{k}:index.html"] = add_section_split_cover(files, manifest, k)
-        end
-        m[k] = files[k]
-      end
-    end
-
-    def add_section_split_cover(files, manifest, ident)
-      cover = section_split_cover(manifest, dir_name_cleanse(ident))
-      files[ident][:out_path] = cover
-      { attachment: true, index: false, out_path: cover,
-        ref: File.join(File.dirname(manifest.file), cover) }
-    end
-
-    def section_split_cover(col, ident)
-      dir = File.dirname(col.file)
-      @compile.collection_setup(nil, dir)
-      CollectionRenderer.new(col, dir,
-                             output_folder: "#{ident}_collection",
-                             format: %i(html),
-                             coverpage: File.join(dir, "cover.html")).coverpage
-      FileUtils.mv "#{ident}_collection/index.html",
-                   File.join(dir, "#{ident}_index.html")
-      FileUtils.rm_rf "#{ident}_collection"
-      "#{ident}_index.html"
-    end
-
-    def add_section_split_instance(file, manifest, key, idx, files)
-      presfile = File.join(File.dirname(files[key][:ref]),
-                           File.basename(file[:url]))
-      manifest["#{key} #{file[:title]}"] =
-        { parentid: key, presentationxml: true, type: "fileref",
-          rel_path: file[:url], out_path: File.basename(file[:url]),
-          anchors: read_anchors(Nokogiri::XML(File.read(presfile))),
-          bibdata: files[key][:bibdata], ref: presfile }
-      manifest["#{key} #{file[:title]}"][:bare] = true unless idx.zero?
-    end
-
-    def sectionsplit(file)
-      @compile.compile(
-        file, { format: :asciidoc, extension_keys: [:presentation] }
-        .merge(@compile_options)
-      )
-      r = file.sub(/\.xml$/, ".presentation.xml")
-      xml = Nokogiri::XML(File.read(r))
-      s = @compile.sectionsplit(xml, File.basename(r), File.dirname(r))
-        .sort_by { |f| f[:order] }
-      [s, @compile.collection_manifest(File.basename(r), s, xml, nil,
-                                       File.dirname(r))]
-    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, _path)
-      out = ref["attachment"] ? ref["fileref"] : File.basename(ref["fileref"])
-      ret = if ref["fileref"]
-              { type: "fileref", ref: @documents[identifier].file,
-                rel_path: ref["fileref"], out_path: out }
-            else { type: "id", ref: ref["id"] }
-            end
-      %i(attachment sectionsplit index).each do |s|
-        ret[s] = ref[s.to_s] if ref[s.to_s]
-      end
-      ret[:presentationxml] = ref["presentation-xml"]
-      ret[:bareafterfirst] = ref["bare-after-first"]
-      ret.compact
-    end
-
-    def add_suffix_to_attributes(doc, suffix, tag_name, attribute_name)
-      doc.xpath(ns("//#{tag_name}[@#{attribute_name}]")).each do |elem|
-        elem.attributes[attribute_name].value =
-          "#{elem.attributes[attribute_name].value}_#{suffix}"
-      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)|
-        add_suffix_to_attributes(doc, document_suffix, tag_name, attribute_name)
-      end
-      url_in_css_styles(doc, 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
-
-    # @param ref [String]
-    # @param read [Boolean]
-    # @param doc [Boolean]
-    # @return [Array<String, nil>]
-    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
-=end
-
     # compile and output individual file in collection
     # warn "metanorma compile -x html #{f.path}"
     def file_compile(file, filename, identifier)
-      #return if @files[identifier][:sectionsplit] == "true"
-      return if @files.get(identifier,:sectionsplit) == "true"
+      return if @files.get(identifier, :sectionsplit) == "true"
 
       opts = {
         format: :asciidoc,
@@ -181,49 +19,38 @@ module Metanorma
       }.merge(compile_options_update(identifier))
 
       @compile.compile file, opts
-      #@files[identifier][:outputs] = {}
-      @files.set(identifier,:outputs, {})
+      @files.set(identifier, :outputs, {})
       file_compile_formats(filename, identifier)
     end
 
     def compile_options_update(identifier)
       ret = @compile_options.dup
       Array(@directives).include?("presentation-xml") ||
-        #@files[identifier][:presentationxml] and
-        @files.get(identifier,:presentationxml) and
+        @files.get(identifier, :presentationxml) and
         ret.merge!(passthrough_presentation_xml: true)
-      #@files[identifier][:sectionsplit] == "true" and
-      @files.get(identifier,:sectionsplit) == "true" and
+      @files.get(identifier, :sectionsplit) == "true" and
         ret.merge!(sectionsplit: "true")
-      #@files[identifier][:bare] == true and
-      @files.get(identifier,:bare) == true and
+      @files.get(identifier, :bare) == true and
         ret.merge!(bare: true)
       ret
     end
 
     def file_compile_formats(filename, identifier)
-      #file_id = @files[identifier]
       f = @files.get(identifier, :outputs)
       @format << :presentation if @format.include?(:pdf)
       @format.each do |e|
         ext = @compile.processor.output_formats[e]
         fn = File.basename(filename).sub(/(?<=\.)[^.]+$/, ext.to_s)
-        #unless /html$/.match?(ext) && file_id[:sectionsplit]
-        unless /html$/.match?(ext) && @files.get(identifier, :sectionsplit)
-          #file_id[:outputs][e] = File.join(@outdir, fn)
+        (/html$/.match?(ext) && @files.get(identifier, :sectionsplit)) or
           f[e] = File.join(@outdir, fn)
-        end
       end
-      @files.set(identifier,:outputs, f)
+      @files.set(identifier, :outputs, f)
     end
 
-    #def copy_file_to_dest(fileref)
     def copy_file_to_dest(identifier)
-      dest = File.join(@outdir, @files.get(identifier,:out_path))
+      dest = File.join(@outdir, @files.get(identifier, :out_path))
       FileUtils.mkdir_p(File.dirname(dest))
-      #FileUtils.cp fileref[:ref], dest
-      #require "debug"; binding.b
-      FileUtils.cp @files.get(identifier,:ref), dest
+      FileUtils.cp @files.get(identifier, :ref), dest
     end
 
     # process each file in the collection
@@ -231,22 +58,19 @@ module Metanorma
     def files # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       warn "\n\n\n\n\nInternal Refs: #{DateTime.now.strftime('%H:%M:%S')}"
       internal_refs = locate_internal_refs
-      #@files.each_with_index do |(identifier, x), i|
-      @files.keys.each_with_index do |identifier, i|
+      @files.keys.each_with_index do |ident, i|
         i.positive? && Array(@directives).include?("bare-after-first") and
           @compile_options.merge!(bare: true)
-        #if x[:attachment] then copy_file_to_dest(x)
-        if @files.get(identifier,:attachment) then copy_file_to_dest(identifier)
+        if @files.get(ident, :attachment) then copy_file_to_dest(ident)
         else
-          #file, filename = @files.targetfile(x, read: true)
-          file, filename = @files.targetfile_id(identifier, read: true)
+          file, filename = @files.targetfile_id(ident, read: true)
           warn "\n\n\n\n\nProcess #{filename}: #{DateTime.now.strftime('%H:%M:%S')}"
-          collection_xml = update_xrefs(file, identifier, internal_refs)
+          collection_xml = update_xrefs(file, ident, internal_refs)
           collection_filename = File.basename(filename, File.extname(filename))
           collection_xml_path = File.join(Dir.tmpdir,
                                           "#{collection_filename}.xml")
           File.write collection_xml_path, collection_xml, encoding: "UTF-8"
-          file_compile(collection_xml_path, filename, identifier)
+          file_compile(collection_xml_path, filename, ident)
           FileUtils.rm(collection_xml_path)
         end
       end

data/lib/metanorma/collection_manifest.rb

@@ -108,9 +108,7 @@ module Metanorma
       @disambig = Util::DisambigFiles.new
       @docref.each do |dr|
         drf = builder.docref do |b|
-          b.identifier do |i|
-            i << dr["identifier"]
-          end
+          b.identifier { |i| i << dr["identifier"] }
           !dr["attachment"] && !dr["sectionsplit"] &&
             d = @collection.bibdatas[dr["identifier"]] and
             b.parent.add_child(d.bibitem.to_xml(bibdata: true))

data/lib/metanorma/collection_render_utils.rb

@@ -0,0 +1,111 @@
+module Metanorma
+  class CollectionRenderer
+    def dir_name_cleanse(name)
+      path = Pathname.new(name)
+      clean_regex = /[<>:"|?*]/
+      fallback_sym = "_"
+      return name.gsub(clean_regex, fallback_sym) unless path.absolute?
+
+      File.join(path.dirname,
+                path.basename.to_s.gsub(clean_regex, fallback_sym))
+    end
+
+    private
+
+    def create_non_existing_directory(output_directory)
+      !File.exist?(output_directory) and
+        FileUtils.mkdir_p(output_directory)
+    end
+
+    def format_sort(formats)
+      ret = []
+      formats.include?(:xml) and ret << :xml
+      formats.include?(:presentation) and ret << :presentation
+      a = %i(presentation xml)
+      ret + formats.reject { |i| a.include? i }
+    end
+
+    # @param options [Hash]
+    # @raise [ArgumentError]
+    def check_options(options)
+      (options[:format].is_a?(Array) && (FORMATS & options[:format]).any?) or
+        raise ArgumentError, "Need to specify formats (xml,html,pdf,doc)"
+    end
+
+    def pdfconv
+      doctype = @doctype.to_sym
+      x = Asciidoctor.load nil, backend: doctype
+      x.converter.pdf_converter(PdfOptionsNode.new(doctype,
+                                                   @compile_options))
+    end
+
+    def fail_update_bibitem(docid, identifier)
+      error = "[metanorma] Cannot find crossreference to document #{docid} " \
+              "in document #{identifier}."
+      @log&.add("Cross-References", nil, error)
+      Util.log(error, :warning)
+    end
+
+    def datauri_encode(docxml)
+      docxml.xpath(ns("//image")).each do |i|
+        i["src"] = Metanorma::Utils::datauri(i["src"])
+      end
+      docxml
+    end
+
+    class PdfOptionsNode
+      def initialize(doctype, options)
+        docproc = Metanorma::Registry.instance.find_processor(doctype)
+        if FontistUtils.has_fonts_manifest?(docproc, options)
+          @fonts_manifest = FontistUtils.location_manifest(docproc)
+        end
+      end
+
+      def attr(key)
+        if key == "fonts-manifest" && @fonts_manifest
+          @fonts_manifest
+        end
+      end
+    end
+
+    class Dummy
+      def attr(_key); end
+    end
+
+    def isodoc_create
+      x = Asciidoctor.load nil, backend: @doctype.to_sym
+      isodoc = x.converter.html_converter(Dummy.new) # to obtain Isodoc class
+      isodoc.i18n_init(@lang, @script, @locale) # read in internationalisation
+      isodoc.metadata_init(@lang, @script, @locale, isodoc.i18n)
+      isodoc.info(@xml, nil)
+      isodoc
+    end
+
+    def isodoc_populate
+      # create the @meta class of isodoc, for populating Liquid,
+      # with "navigation" set to the index bar.
+      # extracted from the manifest
+      @isodoc.meta.set(:navigation, indexfile(@xml.at(ns("//manifest"))))
+      @isodoc.meta.set(:docrefs, liquid_docrefs)
+      @isodoc.meta.set(:"prefatory-content",
+                       isodoc_builder(@isodoc,
+                                      @xml.at(ns("//prefatory-content"))))
+      @isodoc.meta.set(:"final-content",
+                       isodoc_builder(isodoc,
+                                      @xml.at(ns("//final-content"))))
+      @isodoc.info(@xml, nil)
+    end
+
+    def isodoc_builder(isodoc, node)
+      Nokogiri::HTML::Builder.new(encoding: "UTF-8") do |b|
+        b.div do |div|
+          node&.children&.each { |n| isodoc.parse(n, div) }
+        end
+      end.doc.root.to_html
+    end
+
+    def ns(xpath)
+      @isodoc.ns(xpath)
+    end
+  end
+end

data/lib/metanorma/collection_renderer.rb

@@ -1,11 +1,10 @@
-# frozen_string_literal: true
-
 require "isodoc"
 require "htmlentities"
 require_relative "collection_fileprocess"
 require_relative "fontist_utils"
 require_relative "util"
 require_relative "files_lookup"
+require_relative "collection_render_utils"
 
 module Metanorma
   # XML collection renderer
@@ -30,9 +29,9 @@ module Metanorma
     def initialize(collection, folder, options = {}) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
       check_options options
       @xml = Nokogiri::XML collection.to_xml # @xml is the collection manifest
-      @lang = @xml.at(ns("//bibdata/language"))&.text || "en"
-      @script = @xml.at(ns("//bibdata/script"))&.text || "Latn"
-      @locale = @xml.at(ns("//bibdata/locale"))&.text
+      @lang = @xml.at("//xmlns:bibdata/xmlns:language")&.text || "en"
+      @script = @xml.at("//xmlns:bibdata/xmlns:script")&.text || "Latn"
+      @locale = @xml.at("//xmlns:bibdata/xmlns:locale")&.text
       @doctype = doctype
       require "metanorma-#{@doctype}"
 
@@ -49,22 +48,19 @@ module Metanorma
       @disambig = Util::DisambigFiles.new
       @compile = Compile.new
       @c = HTMLEntities.new
+      @files_to_delete = []
 
       # list of files in the collection
-      #@files = read_files folder
       @files = Metanorma::FileLookup.new(folder, self)
+      @files.add_section_split
       isodoc_populate
       create_non_existing_directory(@outdir)
     end
 
-    def dir_name_cleanse(name)
-      path = Pathname.new(name)
-      clean_regex = /[<>:"|?*]/
-      fallback_sym = "_"
-      return name.gsub(clean_regex, fallback_sym) unless path.absolute?
-
-      File.join(path.dirname,
-                path.basename.to_s.gsub(clean_regex, fallback_sym))
+    def flush_files
+      warn @files.files_to_delete
+      @files.files_to_delete.each { |f| FileUtils.rm_f(f) }
+      @files_to_delete.each { |f| FileUtils.rm_f(f) }
     end
 
     # @param col [Metanorma::Collection] XML collection
@@ -83,14 +79,14 @@ module Metanorma
       warn "\n\n\n\n\nCoverpage: #{DateTime.now.strftime('%H:%M:%S')}"
       cr.coverpage if options[:format]&.include?(:html)
       warn "\n\n\n\n\nDone: #{DateTime.now.strftime('%H:%M:%S')}"
+      cr.flush_files
       cr
     end
 
     def concatenate(col, options)
       options[:format] << :presentation if options[:format].include?(:pdf)
       options[:format].uniq.each do |e|
-        next unless %i(presentation xml).include?(e)
-
+        %i(presentation xml).include?(e) or next
         ext = e == :presentation ? "presentation.xml" : e.to_s
         File.open(File.join(@outdir, "collection.#{ext}"), "w:UTF-8") do |f|
           f.write(concatenate1(col.clone, e).to_xml)
@@ -103,79 +99,20 @@ module Metanorma
     def concatenate1(out, ext)
       out.directives << "documents-inline"
       out.bibdatas.each_key do |ident|
-        #id = @c.decode(@isodoc.docid_prefix(nil, ident.dup))
-        #@files[id][:attachment] || @files[id][:outputs].nil? and next
         id = @isodoc.docid_prefix(nil, ident.dup)
-        @files.get(id,:attachment) || @files.get(id,:outputs).nil? and next
+        @files.get(id, :attachment) || @files.get(id, :outputs).nil? and next
 
         out.documents[id] =
-          #Metanorma::Document.raw_file(@files[id][:outputs][ext])
-          Metanorma::Document.raw_file(@files.get(id,:outputs)[ext])
+          Metanorma::Document.raw_file(@files.get(id, :outputs)[ext])
       end
       out
     end
 
-    def pdfconv
-      doctype = @doctype.to_sym
-      x = Asciidoctor.load nil, backend: doctype
-      x.converter.pdf_converter(PdfOptionsNode.new(doctype, @compile_options))
-    end
-
-    class PdfOptionsNode
-      def initialize(doctype, options)
-        docproc = Metanorma::Registry.instance.find_processor(doctype)
-        if FontistUtils.has_fonts_manifest?(docproc, options)
-          @fonts_manifest = FontistUtils.location_manifest(docproc)
-        end
-      end
-
-      def attr(key)
-        if key == "fonts-manifest" && @fonts_manifest
-          @fonts_manifest
-        end
-      end
-    end
-
-    class Dummy
-      def attr(_key); end
-    end
-
-    def isodoc_create
-      x = Asciidoctor.load nil, backend: @doctype.to_sym
-      isodoc = x.converter.html_converter(Dummy.new) # to obtain Isodoc class
-      isodoc.i18n_init(@lang, @script, @locale) # read in internationalisation
-      isodoc.metadata_init(@lang, @script, @locale, isodoc.i18n)
-      isodoc.info(@xml, nil)
-      isodoc
-    end
-
-    def isodoc_populate
-      # create the @meta class of isodoc, for populating Liquid,
-      # with "navigation" set to the index bar.
-      # extracted from the manifest
-      @isodoc.meta.set(:navigation, indexfile(@xml.at(ns("//manifest"))))
-      @isodoc.meta.set(:docrefs, liquid_docrefs)
-      @isodoc.meta.set(:"prefatory-content",
-                      isodoc_builder(@isodoc,
-                                     @xml.at(ns("//prefatory-content"))))
-      @isodoc.meta.set(:"final-content",
-                      isodoc_builder(isodoc, @xml.at(ns("//final-content"))))
-      @isodoc.info(@xml, nil)
-    end
-
-    def isodoc_builder(isodoc, node)
-      Nokogiri::HTML::Builder.new(encoding: "UTF-8") do |b|
-        b.div do |div|
-          node&.children&.each { |n| isodoc.parse(n, div) }
-        end
-      end.doc.root.to_html
-    end
-
     # infer the flavour from the first document identifier; relaton does that
     def doctype
-      if (docid = @xml.at(ns("//bibdata/docidentifier/@type"))&.text)
+      if (docid = @xml.at("//xmlns:bibdata/xmlns:docidentifier/@type")&.text)
         dt = docid.downcase
-      elsif (docid = @xml.at(ns("//bibdata/docidentifier"))&.text)
+      elsif (docid = @xml.at("//xmlns:bibdata/xmlns:docidentifier")&.text)
         dt = docid.sub(/\s.*$/, "").lowercase
       else return "standoc"
       end
@@ -183,10 +120,6 @@ module Metanorma
       @registry.alias(dt.to_sym)&.to_s || dt
     end
 
-    def ns(xpath)
-      IsoDoc::Convert.new({}).ns(xpath)
-    end
-
     # populate liquid template of ARGV[1] with metadata extracted from
     # collection manifest
     def coverpage
@@ -233,8 +166,7 @@ module Metanorma
 
     def index_link(docref, ident)
       if docref["fileref"]
-        #@files[ident][:out_path].sub(/\.xml$/, ".html")
-        @files.get(ident,:out_path).sub(/\.xml$/, ".html")
+        @files.get(ident, :out_path).sub(/\.xml$/, ".html")
       else "#{docref['id']}.html"
       end
     end
@@ -270,27 +202,5 @@ module Metanorma
                "level" => d.at(ns("./level"))&.text }
       end
     end
-
-    private
-
-    def create_non_existing_directory(output_directory)
-      !File.exist?(output_directory) and
-        FileUtils.mkdir_p(output_directory)
-    end
-
-    def format_sort(formats)
-      ret = []
-      formats.include?(:xml) and ret << :xml
-      formats.include?(:presentation) and ret << :presentation
-      a = %i(presentation xml)
-      ret + formats.reject { |i| a.include? i }
-    end
-
-    # @param options [Hash]
-    # @raise [ArgumentError]
-    def check_options(options)
-      (options[:format].is_a?(Array) && (FORMATS & options[:format]).any?) or
-        raise ArgumentError, "Need to specify formats (xml,html,pdf,doc)"
-    end
   end
 end

data/lib/metanorma/compile.rb

@@ -176,6 +176,21 @@ module Metanorma
       ext != :presentation
     end
 
+     # assume we pass in Presentation XML, but we want to recover Semantic XML
+    def sectionsplit_convert(input_filename, file, output_filename = nil,
+                             opts = {})
+      @isodoc ||= IsoDoc::PresentationXMLConvert.new({})
+      input_filename += ".xml" unless input_filename.match?(/\.xml$/)
+      File.exist?(input_filename) or
+        File.open(input_filename, "w:UTF-8") { |f| f.write(file) }
+      presxml = File.read(input_filename, encoding: "utf-8")
+      _xml, filename, dir = @isodoc.convert_init(presxml, input_filename, false)
+      Sectionsplit.new(input: input_filename, isodoc: @isodoc, xml: presxml,
+                       base: File.basename(output_filename || filename),
+                       output: output_filename || filename,
+                       dir: dir, compile_opts: opts).build_collection
+    end
+
     private
 
     def isodoc_error_process(err, strict, must_abort)

data/lib/metanorma/compile_options.rb

@@ -7,7 +7,7 @@ module Metanorma
     end
 
     def xml_options_extract(file)
-      xml = Nokogiri::XML(file) { |config| config.huge }
+      xml = Nokogiri::XML(file, &:huge)
       if xml.root
         @registry.root_tags.each do |k, v|
           return { type: k } if v == xml.root.name
@@ -36,29 +36,33 @@ module Metanorma
     def get_extensions(options)
       options[:extension_keys] ||=
         @processor.output_formats.reduce([]) { |memo, (k, _)| memo << k }
-      extensions = options[:extension_keys].reduce([]) do |memo, e|
+      extensions = extract_extensions(options)
+      if !extensions.include?(:presentation) && extensions.any? do |e|
+        @processor.use_presentation_xml(e)
+      end
+        extensions << :presentation
+      end
+      extensions
+    end
+
+    def extract_extensions(options)
+      options[:extension_keys].reduce([]) do |memo, e|
         if @processor.output_formats[e] then memo << e
         else
-          message = "[metanorma] Error: #{e} format is not supported for this standard."
+          message = "[metanorma] Error: #{e} format is not supported " \
+                    "for this standard."
           @errors << message
           Util.log(message, :error)
           memo
         end
       end
-      if !extensions.include?(:presentation) && extensions.any? do |e|
-        @processor.use_presentation_xml(e)
-      end
-        extensions << :presentation
-      end
-      extensions
     end
 
     def font_install(opt)
       FontistUtils.install_fonts(@processor, opt) unless @fontist_installed
       @fontist_installed = true
-      return if !opt[:fonts] ||
-        opt[:fontlicenseagreement] == "continue-without-fonts"
-
+      !opt[:fonts] ||
+        opt[:fontlicenseagreement] == "continue-without-fonts" and return
       @font_overrides ||= []
       font_install_override(opt)
     end

data/lib/metanorma/document.rb

@@ -87,7 +87,7 @@ module Metanorma
         else
           case format(file)
           when :xml
-            from_xml Nokogiri::XML(File.read(file, encoding: "UTF-8"))
+            from_xml (Nokogiri::XML(File.read(file, encoding: "UTF-8")) { |x| x.huge })
           when :yaml
             yaml = File.read(file, encoding: "UTF-8")
             Relaton::Cli::YAMLConvertor.convert_single_file(yaml)