metanorma 2.0.0 → 2.5.5

data/lib/metanorma/collection/xrefprocess/xrefprocess.rb

@@ -5,14 +5,15 @@ module Metanorma
         # xml.root["type"] = key # to force recognition of internal refs
         # bookmarks etc as new id elements introduced in Presentation XML:
         # add doc suffix
+        # Run on Semantic XML
         def xref_preprocess(xml, isodoc)
           @isodoc = isodoc
           key = (0...8).map { rand(65..90).chr }.join # random string
           xml.root["type"] = key
-          Metanorma::Utils::anchor_attributes
-            .each do |(tag_name, attribute_name)|
-            ::Metanorma::Collection::Util::add_suffix_to_attributes(
-              xml, xml.root["document_suffix"], tag_name, attribute_name, isodoc
+          Util::anchor_id_attributes.each do |(tag_name, attr_name)|
+              #tag_name == "xref" and tag_name = "fmt-xref"
+            ::Metanorma::Collection::Util::add_suffix_to_attrs(
+              xml, xml.root["document_suffix"], tag_name, attr_name, isodoc
             )
           end
           key
@@ -22,38 +23,39 @@ module Metanorma
           @isodoc.ns(xpath)
         end
 
-        def xref_process(section, xml, key, ident, isodoc)
+        def xref_process(section, xml, key, ident, isodoc, presxml)
           @isodoc ||= isodoc
-          svg_preprocess(section, Metanorma::Utils::to_ncname(ident))
-          refs = eref_to_internal_eref(section, xml, key)
-          refs += xref_to_internal_eref(section, xml, key)
+          svg_preprocess(section, Metanorma::Utils::to_ncname(ident), presxml)
+          refs = eref_to_internal_eref(section, xml, key, presxml)
+          refs += xref_to_internal_eref(section, xml, key, presxml)
           ins = new_hidden_ref(section)
           copied_refs = copy_repo_items_biblio(ins, section, xml)
           insert_indirect_biblio(ins, refs - copied_refs, key, xml)
         end
 
-        def svg_preprocess(xml, doc_suffix)
+        def svg_preprocess(xml, doc_suffix, presxml)
           suffix = doc_suffix.nil? || doc_suffix.blank? ? "" : "_#{doc_suffix}"
           xml.xpath("//m:svg", "m" => "http://www.w3.org/2000/svg").each do |s|
-            m = svgmap_wrap(s)
-            svg_xrefs(s, m, suffix)
+            m = svgmap_wrap(s) or next
+            svg_xrefs(s, m, suffix, presxml)
           end
           xml
         end
 
         def svgmap_wrap(svg)
           ret = svg.at("./ancestor::xmlns:svgmap") and return ret
-          ret = svg.at("./ancestor::xmlns:figure")
+          ret = svg.at("./ancestor::xmlns:figure") or return
           ret.wrap("<svgmap/>")
           svg.at("./ancestor::xmlns:svgmap")
         end
 
-        def svg_xrefs(svg, svgmap, suffix)
+        def svg_xrefs(svg, svgmap, suffix, presxml)
+          tag = presxml ? "fmt-xref" : "xref"
           svg.xpath(".//m:a", "m" => "http://www.w3.org/2000/svg").each do |a|
             /^#/.match? a["href"] or next
             a["href"] = a["href"].sub(/^#/, "")
             svgmap << "<target href='#{a['href']}'>" \
-              "<xref target='#{a['href']}#{suffix}'/></target>"
+              "<#{tag} target='#{a['href']}#{suffix}'/></target>"
           end
         end
 
@@ -65,15 +67,16 @@ module Metanorma
               "#{anchor}</referenceFrom></locality></localityStack>"
         end
 
-        def xref_to_internal_eref(section, xml, key)
+        def xref_to_internal_eref(section, xml, key, presxml)
           key or return [] # no sectionsplit, no playing with xrefs
           bibitems, indirect = xref_to_internal_eref_prep(section, xml)
-          section.xpath(ns("//xref")).each_with_object({}) do |x, m|
+          tag = presxml ? "fmt-xref" : "xref"
+          section.xpath(ns("//#{tag}")).each_with_object({}) do |x, m|
             xref_prefix_key(x, key, indirect)
             x["bibitemid"] = x["target"]
             m[x["bibitemid"]] = true
-            xref_to_internal_eref_anchor(x, key, bibitems,
-                                         xml.root["document_suffix"])
+            xref_to_internal_eref_anchor(x, bibitems,
+                                         xml.root["document_suffix"], presxml)
           end.keys
         end
 
@@ -84,8 +87,9 @@ module Metanorma
           [bibitems, indirect_bibitems]
         end
 
-        def xref_to_internal_eref_anchor(xref, key, bibitems, document_suffix)
+        def xref_to_internal_eref_anchor(xref, bibitems, document_suffix, presxml)
           t = xref["target"]
+          key = xref["type"]
           if d = bibitems[t]&.at(ns("./docidentifier[@type = 'repository']"))
             m = %r{^([^/]+)}.match(d.text) and
               t.sub!(%r(#{m[0]}_), "")
@@ -93,7 +97,7 @@ module Metanorma
           key and t.sub!(%r{^#{key}_}, "")
           make_anchor(xref, t.sub(%r(_#{document_suffix}$), ""))
           xref.delete("target")
-          xref.name = "eref"
+          xref.name = presxml ? "fmt-eref" : "eref"
         end
 
         def xref_prefix_key(xref, key, indirect)
@@ -106,30 +110,40 @@ module Metanorma
           end
         end
 
-        def eref_to_internal_eref(section, xml, key)
-          bibitems, indirect, bibids = eref_to_internal_eref_prep(section, xml)
-          eref_to_internal_eref_select(section, xml, bibitems)
+        def select_citation_uri(bib, lang)
+          bib or return
+          url = bib.at(ns("./uri[@type = 'citation']" \
+                          "[@language = '#{lang}']")) ||
+            bib.at(ns("./uri[@type = 'citation']"))
+          url&.text
+        end
+
+        def eref_to_internal_eref(section, xml, key, presxml)
+          bibitems, indirect, bibids, lang =
+            eref_to_internal_eref_prep(section, xml, presxml)
+          eref_to_internal_eref_select(section, xml, bibitems, presxml)
             .each_with_object([]) do |x, m|
-              url = bibitems[x]&.at(ns("./uri[@type = 'citation']"))&.text
+              url = select_citation_uri(bibitems[x], lang)
               bibids[x]&.each do |e|
                 e.at(ns("./localityStack | ./locality")) and next
-                id = eref_to_internal_eref1(e, key, url, indirect) and m << id
+                id = eref_to_internal_eref1(e, key, url, indirect, presxml) and m << id
               end
             end
         end
 
-        def eref_to_internal_eref_prep(section, xml)
+        def eref_to_internal_eref_prep(section, xml, presxml)
           bibitems = ::Metanorma::Collection::Util::gather_bibitems(xml)
             .delete_if { |_, v| internal_bib?(v) }
           indirect = ::Metanorma::Collection::Util::gather_bibitems(xml)
             .select { |_, v| indirect_bib?(v) }
-          bibitemids = ::Metanorma::Collection::Util::gather_bibitemids(section)
-          [bibitems, indirect, bibitemids]
+          bibitemids = ::Metanorma::Collection::Util::gather_bibitemids(section, presxml)
+          lang = xml.at(ns("//bibdata/language"))&.text || "en"
+          [bibitems, indirect, bibitemids, lang]
         end
 
-        def eref_to_internal_eref1(elem, key, url, indirect)
+        def eref_to_internal_eref1(elem, key, url, indirect, presxml)
           if url
-            elem.name = "link"
+            elem.name = presxml ? "fmt-link" : "link"
             elem["target"] = url
             nil
           elsif !indirect[elem["bibitemid"]]
@@ -152,8 +166,8 @@ module Metanorma
           elem["bibitemid"]
         end
 
-        def eref_to_internal_eref_select(section, _xml, bibitems)
-          refs = ::Metanorma::Collection::Util::gather_bibitemids(section).keys
+        def eref_to_internal_eref_select(section, _xml, bibitems, presxml)
+          refs = ::Metanorma::Collection::Util::gather_bibitemids(section, presxml).keys
           refs.uniq.reject do |x|
             b = bibitems[x] and (indirect_bib?(b) || internal_bib?(b))
           end
@@ -211,7 +225,7 @@ module Metanorma
 
         def new_indirect_bibitem(ident, prefix)
           <<~BIBENTRY
-            <bibitem id="#{ident}" type="internal">
+            <bibitem id="#{ident}" anchor="#{ident}" type="internal">
             <docidentifier type="repository">#{ident.sub(/^#{prefix}_/, "#{prefix}/")}</docidentifier>
             </bibitem>
           BIBENTRY

data/lib/metanorma/compile/assets/icc-boilerplate.adoc

@@ -0,0 +1,41 @@
+== copyright-statement
+=== Copyright notice
+
+Copyright © 1994-{{docyear}} International Color Consortium®
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+the Specification and associated documentation files (the “Specification”) to
+deal in the Specification without restriction, including without limitation the
+rights to use, copy, modify, merge, publish, distribute, and/or sublicense
+copies of the Specification, and to permit persons to whom the Specification is
+furnished to do so, subject to the following conditions.
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Specification.
+
+The Specification is provided "as is", without warranty of any kind, express,
+implied, or otherwise, including but not limited to the warranties of
+merchantability, fitness for a particular purpose and noninfringement. In no
+event shall the International Color Consortium be liable for any claim, damages
+or other liability, whether in an action of contract, tort or otherwise, arising
+from, out of, or in connection with the Specification or the use or other
+dealings in the Specification.
+
+Except as contained in this notice, the name of the International Color
+Consortium shall not be used in advertising or otherwise to promote the use or
+other dealings in this Specification without prior written authorization from
+the International Color Consortium.
+
+== license-statement
+=== Licenses and trademarks
+
+International Color Consortium and the ICC logo are registered trademarks of the
+International Color Consortium. Rather than put a trademark symbol in every
+occurrence of other trademarked names, we state that we are using the names only
+in an editorial fashion, and to the benefit of the trademark owner, with no
+intention of infringement of the trademark.
+
+== feedback-statement
+=== For additional information on the ICC
+
+Visit the ICC Web site: http://www.color.org

data/lib/metanorma/compile/compile.rb

@@ -1,21 +1,38 @@
+# frozen_string_literal: true
+
 require "fileutils"
 require "nokogiri"
 require "htmlentities"
 require "yaml"
 require "fontist"
-require "fontist/manifest/install"
-require_relative "compile_validate"
+require "fontist/manifest"
+require "metanorma-taste"
+require_relative "writeable"
+require_relative "validator"
 require_relative "compile_options"
 require_relative "../util/fontist_helper"
-require_relative "../util/util"
+require "metanorma-core"
 require_relative "extract"
 require_relative "../collection/sectionsplit/sectionsplit"
 require_relative "../util/worker_pool"
+require_relative "output_filename"
+require_relative "output_filename_config"
+require_relative "flavor"
+require_relative "relaton_drop"
+require_relative "render"
 
 module Metanorma
   class Compile
+    include Validator
+    include CompileOptions
+    include Flavor
+    include Writeable
+
+    DEFAULT_NUM_WORKERS = 3
+
     # @return [Array<String>]
-    attr_reader :errors, :processor
+    attr_reader :errors
+    attr_reader :processor
 
     def initialize
       @registry = Metanorma::Registry.instance
@@ -25,21 +42,43 @@ module Metanorma
       @log = Metanorma::Utils::Log.new
     end
 
+    # Main compile method that orchestrates the document conversion process
+    # @param filename [String] path to the input file
+    # @param options [Hash] compilation options
     def compile(filename, options = {})
-      options_process(filename, options)
+      process_options!(filename, options)
       @processor = @registry.find_processor(options[:type].to_sym)
-      extensions = get_extensions(options) or return nil
-      (file, isodoc = process_input(filename, options)) or return nil
-      relaton_export(isodoc, options)
-      extract(isodoc, options[:extract], options[:extract_type])
-      process_exts(filename, extensions, file, isodoc, options)
+
+      # Step 1: Generate Semantic XML
+      semantic_result = generate_semantic_xml(filename, options) or return nil
+      source_file, semantic_xml = semantic_result
+
+      # Step 2: Prepare output paths
+      xml = Nokogiri::XML(semantic_xml, &:huge)
+      bibdata = extract_relaton_metadata(xml)
+      output_paths = prepare_output_paths(filename, bibdata, options)
+
+      # Step 3: Determine which output formats to generate
+      extensions = get_extensions(options)
+      @extensions = extensions # Capture extensions for later access
+      extensions or return nil
+
+      # Step 4: Extract information from Semantic XML if requested
+      extract_information(semantic_xml, bibdata, options)
+
+      # Step 5: Generate output formats from Semantic XML
+      generate_outputs(
+        source_file, semantic_xml, bibdata, extensions, output_paths,
+        options
+      )
+    ensure
       clean_exit(options)
     end
 
-    def options_process(filename, options)
+    def process_options!(filename, options)
       require_libraries(options)
-      options = options_extract(filename, options)
-      validate_options(options)
+      options = extract_options(filename, options)
+      validate_options!(options)
       @log.save_to(filename, options[:output_dir])
       options[:log] = @log
     end
@@ -49,7 +88,11 @@ module Metanorma
       @log.write
     end
 
-    def process_input(filename, options)
+    # Step 1: Generate Semantic XML from input file
+    # @param filename [String] input file path
+    # @param options [Hash] compilation options
+    # @return [Array, nil] tuple of [source_file, semantic_xml] or nil on failure
+    def generate_semantic_xml(filename, options)
       case extname = File.extname(filename)
       when ".adoc" then process_input_adoc(filename, options)
       when ".xml" then process_input_xml(filename, options)
@@ -60,175 +103,157 @@ module Metanorma
       end
     end
 
-    def process_input_adoc(filename, options)
-      Util.log("[metanorma] Processing: AsciiDoc input.", :info)
-      file = read_file(filename)
-      options[:asciimath] and
-        file.sub!(/^(=[^\n]+\n)/, "\\1:mn-keep-asciimath:\n")
-      dir = File.dirname(filename)
-      dir != "." and
-        file = file.gsub(/^include::/, "include::#{dir}/")
-          .gsub(/^embed::/, "embed::#{dir}/")
-      [file, @processor.input_to_isodoc(file, filename, options)]
+    # Step 2: Prepare output paths for generated files
+    # Use default filename template if empty string is provided.
+    #
+    # @param filename [String] input file path
+    # @param bibdata [Nokogiri::XML::Element] the bibliographic data element
+    # @param options [Hash] compilation options
+    # @return [Hash] paths for different output formats
+    def prepare_output_paths(filename, bibdata, options)
+      basename = if options[:filename_template].nil?
+                   filename.sub(/\.[^.]+$/, "")
+                 else
+                   drop = RelatonDrop.new(bibdata)
+                   config = OutputFilenameConfig.new(options[:filename_template])
+                   config.generate_filename(drop)
+                 end
+      @output_filename = OutputFilename.new(
+        basename, options[:output_dir], @processor
+      )
+      {
+        xml: @output_filename.semantic_xml,
+        orig_filename: filename,
+        presentationxml: @output_filename.presentation_xml,
+      }
     end
 
-    def process_input_xml(filename, _options)
-      Util.log("[metanorma] Processing: Metanorma XML input.", :info)
-      # TODO NN: this is a hack -- we should provide/bridge the
-      # document attributes in Metanorma XML
-      ["", read_file(filename)]
+    # Step 4: Extract information from Semantic XML
+    # @param semantic_xml [String] semantic XML content
+    # @param options [Hash] compilation options
+    def extract_information(semantic_xml, bibdata, options)
+      # Extract Relaton bibliographic data
+      export_relaton_from_bibdata(bibdata, options) if options[:relaton]
+      # Extract other components (sourcecode, images, requirements)
+      if options[:extract]
+        Extract.extract(
+          semantic_xml, options[:extract], options[:extract_type]
+        )
+      end
     end
 
-    def read_file(filename)
-      File.read(filename, encoding: "utf-8").gsub("\r\n", "\n")
+    # Step 5: Generate output formats from Semantic XML
+    # @param source_file [String] source file content
+    # @param semantic_xml [String] semantic XML content
+    # @param bibdata [Nokogiri::XML::Element] the bibliographic data element
+    # @param extensions [Array<Symbol>] output formats to generate
+    # @param output_paths [Hash] paths for output files
+    # @param options [Hash] compilation options
+    def generate_outputs(
+      source_file, semantic_xml, bibdata, extensions, output_paths, options
+    )
+      if extensions == %i(presentation)
+        # Just generate presentation XML
+        generate_presentation_xml(
+          source_file, semantic_xml, bibdata, output_paths, options
+        )
+      else
+        # Generate multiple output formats with parallel processing
+        generate_outputs_parallel(
+          source_file, semantic_xml, bibdata, extensions, output_paths, options
+        )
+      end
     end
 
-    def relaton_export(isodoc, options)
-      return unless options[:relaton]
-
-      xml = Nokogiri::XML(isodoc, &:huge)
-      bibdata = xml.at("//bibdata") || xml.at("//xmlns:bibdata")
-      # docid = bibdata&.at("./xmlns:docidentifier")&.text || options[:filename]
-      # outname = docid.sub(/^\s+/, "").sub(/\s+$/, "").gsub(/\s+/, "-") + ".xml"
-      File.open(options[:relaton], "w:UTF-8") { |f| f.write bibdata.to_xml }
+    def process_input_adoc_hdr(file, options)
+      hdr, rest = Metanorma::Input::Asciidoc.new.header(file)
+      attrs = hdr.split("\n")
+      options[:asciimath] and attrs << ":mn-keep-asciimath:"
+      process_input_adoc_overrides(attrs, options)
+      "#{attrs.join("\n")}\n\n#{rest}"
     end
 
-    def export_output(fname, content, **options)
-      mode = options[:binary] ? "wb" : "w:UTF-8"
-      File.open(fname, mode) { |f| f.write content }
+    def process_input_adoc_overrides(attrs, options)
+      Metanorma::TasteRegister.instance.available_tastes
+        .include?(options[:supplied_type]) or return
+      c = Metanorma::TasteRegister.get(options[:supplied_type])
+      c.process_input_adoc_overrides(attrs, options)
     end
 
-    def wrap_html(options, file_extension, outfilename)
-      if options[:wrapper] && /html$/.match(file_extension)
-        outfilename = outfilename.sub(/\.html$/, "")
-        FileUtils.mkdir_p outfilename
-        FileUtils.mv "#{outfilename}.html", outfilename
-        FileUtils.mv "#{outfilename}_images", outfilename, force: true
-      end
+    def process_input_adoc_includes(file, filename)
+      dir = File.dirname(filename)
+      dir != "." and
+        file = file.gsub(/^include::/, "include::#{dir}/")
+          .gsub(/^embed::/, "embed::#{dir}/")
+      file
     end
 
-    # isodoc is Raw Metanorma XML
-    def process_exts(filename, extensions, file, isodoc, options)
-      f = File.expand_path(change_output_dir(options))
-      fnames = { xml: f.sub(/\.[^.]+$/, ".xml"), f: f,
-                 orig_filename: File.expand_path(filename),
-                 presentationxml: f.sub(/\.[^.]+$/, ".presentation.xml") }
-      @queue = ::Metanorma::Util::WorkersPool
-        .new(ENV["METANORMA_PARALLEL"]&.to_i || 3)
-      gather_and_install_fonts(file, options.dup, extensions)
-      process_exts_run(fnames, file, isodoc, extensions, options)
-      @queue.shutdown
+    def process_input_adoc(filename, options)
+      Util.log("[metanorma] Processing: AsciiDoc input.", :info)
+      file = read_file(filename)
+      file = process_input_adoc_hdr(file, options)
+      file = process_input_adoc_includes(file, filename)
+      update_options_after_preprocessing(file, options)
+      [file, @processor.input_to_isodoc(file, filename, options)]
     end
 
-    def process_exts_run(fnames, file, isodoc, extensions, options)
-      Util.sort_extensions_execution(extensions).each do |ext|
-        process_ext(ext, file, isodoc, fnames, options) or break
+    # need to update options, for any content added;
+    # e.g. new attributes from Metanorma taste
+    def update_options_after_preprocessing(file, options)
+      new_options = { extension_keys: options[:extension_keys] }
+      Tempfile.open(["tmp", ".adoc"], encoding: "UTF-8") do |f|
+        f.write(file)
+        f.close
+        new_options = extract_options(f, new_options)
       end
+      new_options.compact!
+      new_options.delete(:filename)
+      options.merge!(new_options)
     end
 
-    def gather_and_install_fonts(file, options, extensions)
-      Util.sort_extensions_execution(extensions).each do |ext|
-        isodoc_options = get_isodoc_options(file, options, ext)
-        font_install(isodoc_options.merge(options))
-      end
+    def process_input_xml(filename, _options)
+      Util.log("[metanorma] Processing: Metanorma XML input.", :info)
+      # TODO NN: this is a hack -- we should provide/bridge the
+      # document attributes in Metanorma XML
+      ["", read_file(filename)]
     end
 
-    def process_ext(ext, file, isodoc, fnames, options)
-      fnames[:ext] = @processor.output_formats[ext]
-      fnames[:out] = fnames[:f].sub(/\.[^.]+$/, ".#{fnames[:ext]}")
-      isodoc_options = get_isodoc_options(file, options, ext)
-      thread = true
-      unless process_ext_simple(ext, isodoc, fnames, options,
-                                isodoc_options)
-        thread = process_exts1(ext, fnames, isodoc, options, isodoc_options)
-      end
-      thread
-    end
-
-    def process_ext_simple(ext, isodoc, fnames, options, isodoc_options)
-      if ext == :rxl
-        relaton_export(isodoc, options.merge(relaton: fnames[:out]))
-      elsif options[:passthrough_presentation_xml] && ext == :presentation
-        f = File.exist?(fnames[:f]) ? fnames[:f] : fnames[:orig_filename]
-        FileUtils.cp f, fnames[:presentationxml]
-      elsif ext == :html && options[:sectionsplit]
-        sectionsplit_convert(fnames[:xml], isodoc, fnames[:out],
-                             isodoc_options)
-      else return false
-      end
-      true
+    def read_file(filename)
+      File.read(filename, encoding: "utf-8").gsub("\r\n", "\n")
     end
 
-    def process_exts1(ext, fnames, isodoc, options, isodoc_options)
-      if @processor.use_presentation_xml(ext)
-        @queue.schedule(ext, fnames.dup, options.dup,
-                        isodoc_options.dup) do |a, b, c, d|
-          process_output_threaded(a, b, c, d)
+    # Returns a mapping of format types to file suffixes based on the
+    # extensions that were determined during compilation.
+    # This method is only available after compile() has been called and
+    # reached Step 3 where extensions are finalized.
+    #
+    # @return [Hash] mapping of format symbols to file extensions
+    #   e.g., { html: "html", doc: "doc", pdf: "pdf" }
+    # @return [Hash] empty hash if extensions haven't been captured yet
+    def output_format_mapping
+      @extensions && @processor or return {}
+      @extensions.each_with_object({}) do |ext, mapping|
+        if @processor.output_formats[ext]
+          mapping[ext] = @processor.output_formats[ext]
         end
-      else
-        process_output_unthreaded(ext, fnames, isodoc, isodoc_options)
       end
     end
 
-    def process_output_threaded(ext, fnames1, options1, isodoc_options1)
-      @processor.output(nil, fnames1[:presentationxml], fnames1[:out], ext,
-                        isodoc_options1)
-      wrap_html(options1, fnames1[:ext], fnames1[:out])
-    rescue StandardError => e
-      strict = ext == :presentation || isodoc_options1[:strict] == true
-      isodoc_error_process(e, strict, false)
-    end
-
-    def process_output_unthreaded(ext, fnames, isodoc, isodoc_options)
-      @processor.output(isodoc, fnames[:xml], fnames[:out], ext,
-                        isodoc_options)
-      true # return as Thread
-    rescue StandardError => e
-      strict = ext == :presentation || isodoc_options[:strict] == "true"
-      isodoc_error_process(e, strict, true)
-      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)
-
-      ::Metanorma::Collection::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)
-      if strict || err.message.include?("Fatal:")
-        @errors << err.message
-      else
-        puts err.message
-      end
-      puts err.backtrace.join("\n")
-      must_abort and 1
+    def process_compile_dummy(flavor)
+      file = Tempfile.new(%w(tmp .adoc))
+      file.write <<~OUTPUT
+        Document Title
+        :flavor: #{flavor}
+        :mn-output-extensions: xml, presentation
+
+      OUTPUT
+      file.close
+      compile(file.path, agree_to_terms: true)
     end
 
-    # @param options [Hash]
-    # @return [String]
-    def change_output_dir(options)
-      if options[:output_dir]
-        File.join options[:output_dir], File.basename(options[:filename])
-      else options[:filename]
-      end
+    def extract_log_messages(flavor)
+      process_compile_dummy(flavor)
+      @log.display_messages
     end
   end
 end