metanorma 2.3.0 → 2.3.1

data/lib/metanorma/collection/filelookup/filelookup.rb

@@ -1,7 +1,10 @@
 require "isodoc"
 require "htmlentities"
 require "metanorma-utils"
+require "marcel"
 require_relative "filelookup_sectionsplit"
+require_relative "base"
+require_relative "utils"
 
 module Metanorma
   class Collection
@@ -28,12 +31,16 @@ module Metanorma
         read_files(@manifest.entry, parent.manifest)
       end
 
-      def read_files(entries, parent)
+      def read_files(entries, parent, idx = 0)
         Array(entries).each do |e|
           derive_format(e, parent)
-          e.file and read_file(e)
-          read_files(e.entry, e)
+          if e.file
+            read_file(e, idx)
+            idx += 1
+          end
+          idx = read_files(e.entry, e, idx)
         end
+        idx
       end
 
       def derive_format(entry, parent)
@@ -42,9 +49,9 @@ module Metanorma
         entry.format |= ["xml", "presentation"]
       end
 
-      def read_file(manifest)
+      def read_file(manifest, idx)
         i, k = read_file_idents(manifest)
-        entry = file_entry(manifest, k) or return
+        entry = file_entry(manifest, k, idx) or return
         bibdata_process(entry, i)
         bibitem_process(entry)
         @files[key(i)] = entry
@@ -74,12 +81,6 @@ module Metanorma
         end
       end
 
-      def anchors_lookup(anchors)
-        anchors.values.each_with_object({}) do |v, m|
-          v.each_value { |v1| m[v1] = true }
-        end
-      end
-
       def bibdata_extract(xml)
         anchors = read_anchors(xml)
         { anchors: anchors, anchors_lookup: anchors_lookup(anchors),
@@ -100,30 +101,131 @@ module Metanorma
       # out_path is the destination file address, with any references outside
       # the working directory (../../...) truncated, and based on relative path
       # identifier is the id with only spaces, no nbsp
-      def file_entry(ref, identifier)
+      # idx is the index of the document in the manifest
+      def file_entry(ref, identifier, idx)
         ref.file or return
         abs = @documents[Util::key identifier].file
+        # For sectionsplit outputs from YAML manifest, we need to compute the full path
+        # by combining sectionsplit_filename directory with ref.file basename
+        sso = ref.respond_to?(:sectionsplit_output) && ref.sectionsplit_output
+        out_path, rel_path = file_entry_paths(ref, idx, sso)
         ret = if ref.file
-                { type: "fileref", ref: abs, rel_path: ref.file, url: ref.url,
-                  out_path: output_file_path(ref),
-                  format: ref.format&.map(&:to_sym) }.compact
+                { type: "fileref", ref: abs, rel_path: rel_path, url: ref.url,
+                  out_path: out_path, idx: idx,
+                  output_filename: ref.output_filename,
+                  sectionsplit_filename: ref.sectionsplit_filename,
+                  pdffile: ref.pdffile, format: ref.format&.map(&:to_sym) }
+                  .compact
               else { type: "id", ref: ref.id }
               end
         file_entry_copy(ref, ret)
         ret.compact
       end
 
+
+      # ref is the absolute source file address
+      # rel_path is the relative source file address, relative to the YAML location
+      # out_path is the destination file address, with any references outside
+      # the working directory (../../...) truncated, and based on relative path
+      # identifier is the id with only spaces, no nbsp
+      # extract_opts are the compilation options extracted as document attributes
+      def file_entry_struct(ref, abs)
+        adoc = abs.sub(/\.xml$/, ".adoc")
+        if adoc.end_with?(".adoc") && File.exist?(adoc)
+          opts = Metanorma::Input::Asciidoc.new.extract_options(File.read(adoc))
+        end
+        { type: "fileref", ref: abs, rel_path: ref.file, url: ref.url,
+          out_path: output_file_path(ref), pdffile: ref.pdffile,
+          format: ref.format&.map(&:to_sym), extract_opts: opts }.compact
+      end
+
+      def file_entry_paths(ref, idx, sso)
+        base = File.basename(ref.file, ".xml")
+        if sso && ref.respond_to?(:sectionsplit_filename) &&
+            ref.sectionsplit_filename
+          # Extract directory from sectionsplit_filename
+          dir = File.dirname(ref.sectionsplit_filename)
+          if dir == "." # No directory in pattern
+            [output_file_path(ref, idx), ref.file]
+          else # Pattern has directory, prepend it
+            full_path = File.join(dir, base)
+            [full_path, "#{full_path}.xml"]
+          end
+        else [output_file_path(ref, idx), ref.file]
+        end
+      end
+
+      # Substitute special strings in filename patterns
+      # @param pattern [String] filename pattern with placeholders
+      # @param options [Hash] substitution values
+      # @option options [Integer] :document_num document index
+      # @option options [String] :basename filename without extension
+      # @option options [String] :basename_legacy full filename with extension
+      # @option options [Integer] :sectionsplit_num sectionsplit index
+      def substitute_filename_pattern(pattern, options = {})
+        pattern or return pattern
+        result = pattern.dup
+        options[:document_num] and
+          result.gsub!(/\{document-num\}/, options[:document_num].to_s)
+        result.gsub!(/\{basename\}/, options[:basename]) if options[:basename]
+        options[:basename_legacy] and
+          result.gsub!(/\{basename_legacy\}/, options[:basename_legacy])
+        options[:sectionsplit_num] and
+          result.gsub!(/\{sectionsplit-num\}/, options[:sectionsplit_num].to_s)
+        result
+      end
+
       # TODO make the output file location reflect source location universally,
       # not just for attachments: no File.basename
-      def output_file_path(ref)
-        f = File.basename(ref.file)
-        ref.attachment and f = ref.file
-        @disambig.source2dest_filename(f)
+      #
+      # For files with custom directory structure, construct path with directory
+      # For files with output_filename, use that (with substitutions)
+      # For others, use basename of ref.file
+      def output_file_path(ref, idx)
+        has_custom_dir, file_has_dir, params = output_file_path_prep(ref, idx)
+        # Apply sectionsplit_filename directory structure if:
+        # 1. File has sectionsplit enabled (parent document being split), OR
+        # 2. File is a sectionsplit output (from collection or single-file sectionsplit)
+        # Regular files that inherit sectionsplit_filename from collection level
+        # but are not sectionsplit outputs should NOT use it
+        is_sectionsplit_output = ref.respond_to?(:sectionsplit_output) && ref.sectionsplit_output
+        use_sectionsplit_dir = ref.sectionsplit_filename && has_custom_dir &&
+          (ref.sectionsplit || is_sectionsplit_output || file_has_dir)
+        f = if use_sectionsplit_dir
+              # For sectionsplit outputs, return just the basename
+              # The directory will be applied during file_compile_format
+              # via preserve_directory_structure?
+              File.basename(ref.file)
+            elsif ref.output_filename
+              substitute_filename_pattern(ref.output_filename, **params)
+            elsif file_has_dir
+              ref.file # Preserve directory structure already in ref.file
+            elsif ref.attachment
+              ref.file
+            else File.basename(ref.file)
+            end
+        ret = @disambig.source2dest_filename(f, preserve_dirs: ref.attachment)
+        warn ret
+        ret
+      end
+
+      def output_file_path_prep(ref, idx)
+        b = File.basename(ref.file)
+        b_no_ext = File.basename(ref.file, ".*")
+        # Check for sectionsplit_filename (for both parent and split output files)
+        # or output_filename
+        custom_filename = ref.sectionsplit_filename || ref.output_filename
+        has_custom_dir = custom_filename && File.dirname(custom_filename) != "."
+        # Also check if ref.file itself contains a directory
+        file_has_dir = File.dirname(ref.file) != "."
+        params = { document_num: idx, basename: b_no_ext, basename_legacy: b }
+        [has_custom_dir, file_has_dir, params]
       end
 
       def file_entry_copy(ref, ret)
         %w(attachment sectionsplit index presentation-xml url
-           bare-after-first).each do |s|
+           bare-after-first output_filename sectionsplit_filename
+           sectionsplit_output).each do |s|
           ref.respond_to?(s.to_sym) and
             ret[s.delete("-").to_sym] = ref.send(s)
         end
@@ -131,23 +233,16 @@ module Metanorma
 
       def add_document_suffix(identifier, doc)
         document_suffix = Metanorma::Utils::to_ncname(identifier)
+        ids = doc.xpath("./@id | .//@id").map(&:value)
         Util::anchor_id_attributes.each do |(tag_name, attr_name)|
           Util::add_suffix_to_attrs(doc, document_suffix, tag_name, attr_name,
                                     @isodoc)
         end
-        url_in_css_styles(doc, document_suffix)
+        Util::url_in_css_styles(doc, ids, 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 citation url for file
       # @param doc [Boolean] I am a Metanorma document,
       # so my URL should end with html or pdf or whatever
@@ -156,13 +251,6 @@ module Metanorma
         data[:url] || targetfile(data, options)[1]
       end
 
-      # are references to the file to be linked to a file in the collection,
-      # or externally? Determines whether file suffix anchors are to be used
-      def url?(ident)
-        data = get(ident) or return false
-        data[:url]
-      end
-
       # return file contents + output filename for each file in the collection,
       # given a docref entry
       # @param data [Hash] docref entry
@@ -176,7 +264,7 @@ module Metanorma
         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]
+          ref_file path, data, options[:read], options[:doc]
         else
           xml_file data[:id], options[:read]
         end
@@ -186,13 +274,40 @@ module Metanorma
         targetfile(get(ident), options)
       end
 
-      def ref_file(ref, out, read, doc)
+      def ref_file(ref, data, read, doc)
         file = File.read(ref, encoding: "utf-8") if read
-        filename = out.dup
-        filename.sub!(/\.xml$/, ".html") if doc
+        # Use the actual output path from :outputs if available (set after compilation)
+        # Otherwise fall back to :out_path (set at initialization)
+        filename = if doc && data[:outputs] && data[:outputs][:html]
+                     data[:outputs][:html].sub(
+                       %r{^#{Regexp.escape(@parent.outdir)}/}, ""
+                     )
+                   else
+                     data[:out_path].dup
+                   end
+        if doc && !data[:outputs]
+          filename = ref_file_xml2html(filename)
+        end
         [file, filename]
       end
 
+      # Check if file has a recognized MIME type (other than XML)
+      # If so, don't append .html (e.g., .svg, .png, .jpg, etc.)
+      # Only process if it doesn't have a recognized non-XML extension
+      # If filename ends in .xml, replace with .html
+      # Otherwise (including sectionsplit files like "file.xml.0" or
+      # custom titles), append .html
+      def ref_file_xml2html(filename)
+        unless Util::mime_file_recognised?(filename) &&
+            !filename.end_with?(".xml")
+          filename = if filename.end_with?(".xml")
+                       filename.sub(/\.xml$/, ".html")
+                     else "#{filename}.html"
+                     end
+        end
+        filename
+      end
+
       def xml_file(id, read)
         file = @xml.at(ns("//doc-container[@id = '#{id}']")).to_xml if read
         filename = "#{id}.html"
@@ -235,35 +350,19 @@ module Metanorma
         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)
+      # Check if we should preserve directory structure for an identifier
+      # Returns the custom filename if directory structure should be preserved,
+      # nil otherwise
+      def preserve_directory_structure?(ident)
+        ret = if get(ident, :sectionsplit_output)
+                # For sectionsplit outputs, use rel_path which has the directory
+                get(ident, :rel_path) || get(ident, :out_path)
+              elsif get(ident, :sectionsplit)
+                get(ident, :sectionsplit_filename)
+              else get(ident, :output_filename)
+              end
+        # Return the custom filename only if it contains a directory
+        ret && File.dirname(ret) != "." ? ret : nil
       end
     end
   end

data/lib/metanorma/collection/filelookup/filelookup_sectionsplit.rb

@@ -1,5 +1,4 @@
 require_relative "../sectionsplit/sectionsplit"
-# require "concurrent-ruby"
 
 module Metanorma
   class Collection
@@ -7,8 +6,8 @@ module Metanorma
       def add_section_split
         ret = @files.keys.each_with_object({}) do |k, m|
           if @files[k][:sectionsplit] && !@files[k][:attachment]
-            process_section_split_instance(k, m)
-            cleanup_section_split_instance(k, m)
+            original_out_path = process_section_split_instance(k, m)
+            cleanup_section_split_instance(k, m, original_out_path)
           end
           m[k] = @files[k]
         end
@@ -16,6 +15,8 @@ module Metanorma
       end
 
       def process_section_split_instance(key, manifest)
+        # Save the original out_path before it gets modified
+        original_out_path = @files[key][:out_path]
         s, sectionsplit_manifest = sectionsplit(key)
         # section_split_instance_threads(s, manifest, key)
         s.each_with_index do |f1, i|
@@ -24,6 +25,8 @@ module Metanorma
         a = add_section_split_attachments(sectionsplit_manifest, key) and
           manifest["#{key}:attachments"] = a
         add_section_split_cover(manifest, sectionsplit_manifest, key)
+        # Return the original path for cleanup
+        original_out_path
       end
 
       def section_split_instance_threads(s, manifest, key)
@@ -38,8 +41,17 @@ module Metanorma
         pool.wait_for_termination
       end
 
-      def cleanup_section_split_instance(key, manifest)
+      def cleanup_section_split_instance(key, manifest, original_out_path)
+        # Delete the sectionsplit index.html from source directory after it's copied to output
         @files_to_delete << manifest["#{key}:index.html"][:ref]
+        # Delete the original files when sectionsplit happens (all formats: html, xml, presentation.xml)
+        # Use the saved original out_path (before it was changed to index.html)
+        if original_out_path
+          base = File.join(@parent.outdir, original_out_path.sub(/\.xml$/, ""))
+          @files_to_delete << "#{base}.html"
+          @files_to_delete << "#{base}.xml"
+          @files_to_delete << "#{base}.presentation.xml"
+        end
         # @files[key].delete(:ids).delete(:anchors)
         @files[key][:indirect_key] = @sectionsplit.key
       end
@@ -86,20 +98,42 @@ module Metanorma
       def add_section_split_instance(file, manifest, key, idx)
         presfile, newkey, xml = add_section_split_instance_prep(file, key)
         anchors = read_anchors(xml)
+        # Preserve directory structure in out_path if parent has custom sectionsplit_filename with directory
+        sectionsplit_fname = @files[key][:sectionsplit_filename]
+
+        # file[:url] from sectionsplit.rb already has placeholders substituted and includes full path
+        # Use it directly for out_path (without .xml extension)
+        base_filename = File.basename(file[:url], ".xml")
+
+        # Get the directory from file[:url] which already has placeholders substituted
+        file_dir = File.dirname(file[:url])
+
+        # If file[:url] has a directory (i.e., placeholders were substituted), use it
+        out_path_value = if file_dir == "."
+                           base_filename
+                         else
+                           File.join(file_dir, base_filename)
+                         end
+
         m = { parentid: key, presentationxml: true, type: "fileref",
-              rel_path: file[:url], out_path: File.basename(file[:url]),
+              rel_path: out_path_value, out_path: out_path_value,
               anchors: anchors, anchors_lookup: anchors_lookup(anchors),
               ids: read_ids(xml), format: @files[key][:format],
               sectionsplit_output: true, indirect_key: @sectionsplit.key,
-              bibdata: @files[key][:bibdata], ref: presfile }
+              bibdata: @files[key][:bibdata], ref: presfile,
+              sectionsplit_filename: sectionsplit_fname,
+              idx: @files[key][:idx] }
         m[:bare] = true unless idx.zero?
         manifest[newkey] = m
-        @files_to_delete << file[:url]
+        # Don't delete split output files - we want to keep them!
+        # The original parent HTML file is deleted in cleanup_section_split_instance
       end
 
       def add_section_split_instance_prep(file, key)
-        presfile = File.join(File.dirname(@files[key][:ref]),
-                             File.basename(file[:url]))
+        # XML files are always stored flat in the _files directory (no subdirectories)
+        # file[:url] contains full path with directory for HTML output, but XML is basename only
+        xml_basename = File.basename(file[:url])
+        presfile = File.join(File.dirname(@files[key][:ref]), xml_basename)
         newkey = key("#{key.strip} #{file[:title]}")
         xml = Nokogiri::XML(File.read(presfile), &:huge)
         [presfile, newkey, xml]
@@ -107,11 +141,16 @@ module Metanorma
 
       def sectionsplit(ident)
         file = @files[ident][:ref]
+        # @base must always be just basename, never contain directory components
+        # Directory structure comes from sectionsplit_filename pattern only
+        base = File.basename(@files[ident][:out_path] || file)
         @sectionsplit = ::Metanorma::Collection::Sectionsplit
-          .new(input: file, base: @files[ident][:out_path],
+          .new(input: file, base: base,
                dir: File.dirname(file), output: @files[ident][:out_path],
                compile_opts: @parent.compile_options, ident: ident,
                fileslookup: self, isodoc: @isodoc,
+               parent_idx: @files[ident][:idx],
+               sectionsplit_filename: @files[ident][:sectionsplit_filename],
                isodoc_presxml: @isodoc_presxml,
                document_suffix: @files[ident][:document_suffix])
         coll = @sectionsplit.sectionsplit.sort_by { |f| f[:order] }

data/lib/metanorma/collection/filelookup/utils.rb

@@ -0,0 +1,93 @@
+module Metanorma
+  class Collection
+    class FileLookup
+      # 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
+          x["id"] and ret[x["id"]] = true
+        end
+        ret
+      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].gsub(%r{<[^<>]+>}, "")
+                end
+        ret[val[:type]][index] = key
+        v = val[:value] and ret[val[:type]][v.gsub(%r{<[^<>]+>}, "")] = key
+      end
+
+      def anchors_lookup(anchors)
+        anchors.values.each_with_object({}) do |v, m|
+          v.each_value { |v1| m[v1] = true }
+        end
+      end
+
+      # return citation url for file
+      # @param doc [Boolean] I am a Metanorma document,
+      # so my URL should end with html or pdf or whatever
+      def url(ident, options)
+        data = get(ident)
+        data[:url] || targetfile(data, options)[1]
+      end
+
+      # are references to the file to be linked to a file in the collection,
+      # or externally? Determines whether file suffix anchors are to be used
+      def url?(ident)
+        data = get(ident) or return false
+        data[:url]
+      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
+end

data/lib/metanorma/collection/helpers.rb

@@ -0,0 +1,82 @@
+module Metanorma
+  class Collection
+    class << self
+      # @param Block [Proc]
+      # @note allow user-specific function to run in pre-parse model stage
+      def set_pre_parse_model(&block)
+        @pre_parse_model_proc = block
+      end
+
+      # @param Block [Proc]
+      # @note allow user-specific function to resolve identifier
+      def set_identifier_resolver(&block)
+        @identifier_resolver = block
+      end
+
+      # @param Block [Proc]
+      # @note allow user-specific function to resolve fileref
+      # NOTE: MUST ALWAYS RETURN PATH relative to working directory
+      # (initial YAML file location). @fileref_resolver.call(ref_folder, fileref)
+      # fileref is not what is in the YAML, but the resolved path
+      # relative to the working directory
+      def set_fileref_resolver(&block)
+        @fileref_resolver = block
+      end
+
+      def unset_fileref_resolver
+        @fileref_resolver = nil
+      end
+
+      # @param collection_model [Hash{String=>String}]
+      def pre_parse_model(collection_model)
+        @pre_parse_model_proc or return
+        @pre_parse_model_proc.call(collection_model)
+      end
+
+      # @param identifier [String]
+      # @return [String]
+      def resolve_identifier(identifier)
+        @identifier_resolver or return identifier
+        @identifier_resolver.call(identifier)
+      end
+
+      # @param fileref [String]
+      # @return [String]
+      def resolve_fileref(ref_folder, fileref)
+        warn ref_folder
+        warn fileref
+        unless @fileref_resolver
+          (Pathname.new fileref).absolute? or
+            fileref = File.join(ref_folder, fileref)
+          return fileref
+        end
+
+        @fileref_resolver.call(ref_folder, fileref)
+      end
+
+      # @param filepath
+      # @raise [FileNotFoundException]
+      def check_file_existence(filepath)
+        unless File.exist?(filepath)
+          error_message = "#{filepath} not found!"
+          ::Metanorma::Util.log("[metanorma] Error: #{error_message}", :error)
+          raise FileNotFoundException.new error_message.to_s
+        end
+      end
+
+      def parse(file)
+        # need @dirname initialised before collection object initialisation
+        @dirname = File.expand_path(File.dirname(file))
+        config = case file
+                 when /\.xml$/
+                   ::Metanorma::Collection::Config::Config.from_xml(File.read(file))
+                 when /.ya?ml$/
+                   y = YAML.safe_load(File.read(file))
+                   pre_parse_model(y)
+                   ::Metanorma::Collection::Config::Config.from_yaml(y.to_yaml)
+                 end
+        new(file: file, config: config)
+      end
+    end
+  end
+end

data/lib/metanorma/collection/manifest/manifest.rb

@@ -14,7 +14,6 @@ module Metanorma
       # @param docref [Array<Hash{String=>String}>]
       # @param manifest [Array<Metanorma::Collection::Manifest>]
       def initialize(config, collection, dir)
-        #require "debug"; binding.b
         @collection = collection
         @dir = dir
         @disambig = ::Metanorma::Collection::Util::DisambigFiles.new
@@ -22,9 +21,9 @@ module Metanorma
       end
 
       def manifest_postprocess(config)
-        #require "debug"; binding.b
         manifest_bibdata(config)
         manifest_expand_yaml(config, @dir)
+        manifest_output_filenames(config)
         manifest_compile_adoc(config)
         manifest_filexist(config)
         manifest_sectionsplit(config)
@@ -40,6 +39,17 @@ module Metanorma
 
       GUID = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}"
 
+      def manifest_output_filenames(config, parent = nil)
+        config.output_filename ||=
+          parent&.output_filename # || "{basename}.{document-num}"
+        config.sectionsplit_filename ||= parent&.sectionsplit_filename ||
+          "{basename_legacy}.{sectionsplit-num}"
+        # "{basename}-{document-num}.{sectionsplit-num}"
+        Array(config.entry).each do |f|
+          manifest_output_filenames(f, config)
+        end
+      end
+
       def manifest_identifier(config)
         no_id = populate_id_from_doc(config)
         config.identifier =
@@ -169,7 +179,8 @@ module Metanorma
         ::Metanorma::Compile.new
           .compile(f, agree_to_terms: true, install_fonts: false,
                       extension_keys: [:xml])
-        ::Metanorma::Util.log("[metanorma] Info: Compiling #{f}...done!", :warning)
+        ::Metanorma::Util.log("[metanorma] Info: Compiling #{f}...done!",
+                              :warning)
       end
 
       def compile_adoc_file?(file)

data/lib/metanorma/collection/multilingual/multilingual.rb

@@ -617,7 +617,7 @@ module Metanorma
       end
 
       def htmlconv
-        x = Asciidoctor.load nil, backend: @flavor
+        x = Asciidoctor.load nil, backend: Util::taste2flavor(@flavor)
         x.converter.html_converter(@converter_opt)
       end