metanorma 2.3.0 → 2.3.2

data/lib/metanorma/collection/renderer/svg.rb

@@ -1,6 +1,7 @@
 module Metanorma
   class Collection
     class Renderer
+      # Converts SVG images to data URIs for inline embedding
       def svg_datauri(docxml, docid)
         rel = @files.get(docid, :rel_path)
         parent = @files.get(docid, :parentid) and
@@ -10,16 +11,39 @@ module Metanorma
         datauri_encode(docxml, dir)
       end
 
+      # Resolves SVG map references and processes SVG ID disambiguation.
+      #
+      # Delegates SVG manipulation to Vectory gem, which handles:
+      # 1. Document-level suffixing for cross-document ID disambiguation
+      # 2. Index-based suffixing for multiple svgmaps within one document
+      # 3. Link remapping and SVG extraction
+      #
+      # Metanorma's role: State requirements and coordinate the workflow.
+      # Vectory's role: Handle all SVG ID manipulation internally.
+      #
+      # @param docxml [Nokogiri::XML::Document] The document XML to process
+      # @param docid [String] Document identifier for retrieving suffix
+      # @param presxml [Boolean, nil] Whether this is presentation XML
       def svgmap_resolve(docxml, docid, presxml)
         ids, docxml, isodoc, tag = svgmap_resolve_prep(docxml, docid, presxml)
-        docxml.xpath(ns("//svgmap//#{tag}")).each do |e|
-          svgmap_resolve_eref(e, isodoc, docxml, ids, presxml)
-        end
-        svgmap_fmt_prefix_remove(docxml)
-        Vectory::SvgMapping.new(docxml, "").call
-        docxml.xpath(ns("//svgmap")).each { |s| isodoc.svgmap_extract(s) }
+
+        # Stage 1: Resolve EREF references to their targets
+        resolve_svgmap_erefs(docxml, tag, isodoc, ids, presxml)
+
+        # Stage 2: Normalize prefixes (Vectory expects eref, not fmt-eref)
+        normalize_svgmap_prefixes(docxml)
+
+        # Stage 3: Process with Vectory
+        # Pass document suffix to Vectory as id_suffix for proper SVG ID disambiguation.
+        # Vectory handles both id_suffix (document-level) and index suffix internally.
+        doc_suffix = @files.get(docid, :document_suffix)
+        Vectory::SvgMapping.new(docxml, "", id_suffix: doc_suffix).call
+
+        # Stage 4: Extract processed SVG content
+        extract_svgmap_content(docxml, isodoc)
       end
 
+      # Prepares document and context for svgmap resolution
       def svgmap_resolve_prep(docxml, docid, presxml)
         ids = @files.get(docid, :ids)
         docxml = svg_unnest(svg_datauri(docxml, docid))
@@ -29,7 +53,28 @@ module Metanorma
         [ids, docxml, isodoc, tag]
       end
 
-      # undo Presentation XML update: Vectory takes eref not fmt-eref
+      private
+
+      # Resolves EREF elements within svgmap to their actual link targets
+      def resolve_svgmap_erefs(docxml, tag, isodoc, ids, presxml)
+        docxml.xpath(ns("//svgmap//#{tag}")).each do |e|
+          svgmap_resolve_eref(e, isodoc, docxml, ids, presxml)
+        end
+      end
+
+      # Converts fmt-eref/fmt-link/fmt-xref back to eref/link/xref
+      # Vectory expects non-prefixed element names for proper processing
+      def normalize_svgmap_prefixes(docxml)
+        svgmap_fmt_prefix_remove(docxml)
+      end
+
+      # Extracts processed SVG content from svgmap elements
+      def extract_svgmap_content(docxml, isodoc)
+        docxml.xpath(ns("//svgmap")).each { |s| isodoc.svgmap_extract(s) }
+      end
+
+      # Converts Presentation XML fmt- prefix back to standard element names
+      # Vectory expects eref/link/xref, not fmt-eref/fmt-link/fmt-xref
       def svgmap_fmt_prefix_remove(docxml)
         docxml.xpath(ns("//svgmap/target")).each do |t|
           n = t.at(ns(".//fmt-link | .//fmt-xref | .//fmt-eref")) or next
@@ -38,6 +83,7 @@ module Metanorma
         end
       end
 
+      # Removes nested image elements within svgmap, flattening the structure
       def svg_unnest(docxml)
         docxml.xpath(ns("//svgmap//image[.//*[name() = 'image']]")).each do |i|
           s = i.elements.detect { |e| e.name == "svg" } and
@@ -46,6 +92,7 @@ module Metanorma
         docxml
       end
 
+      # Resolves a single EREF element to its target link
       def svgmap_resolve_eref(eref, isodoc, _docxml, ids, presxml)
         href = isodoc.eref_target(eref) or return
         href = href[:link]

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

@@ -1,3 +1,5 @@
+require "marcel"
+
 module Metanorma
   class Collection
     class Renderer
@@ -5,8 +7,7 @@ module Metanorma
         path = Pathname.new(name)
         clean_regex = /[<>:"|?*\p{Zs}]/
         fallback_sym = "_"
-        return name.gsub(clean_regex, fallback_sym) unless path.absolute?
-
+        path.absolute? or return name.gsub(clean_regex, fallback_sym)
         File.join(path.dirname,
                   path.basename.to_s.gsub(clean_regex, fallback_sym))
       end
@@ -38,9 +39,9 @@ module Metanorma
         end
       end
 
-      def new_hidden_ref(xmldoc)
-        ins = xmldoc.at(ns("bibliography")) or
-          xmldoc.root << "<bibliography/>" and ins = xmldoc.at(ns("bibliography"))
+      def new_hidden_ref(xml)
+        ins = xml.at(ns("bibliography")) or
+          xml.root << "<bibliography/>" and ins = xml.at(ns("bibliography"))
         ins.at(ns("./references[@hidden = 'true']")) or
           ins.add_child("<references hidden='true' normative='false'/>").first
       end
@@ -60,8 +61,8 @@ module Metanorma
         tag = presxml ? "fmt-eref" : "eref"
         docxml.xpath(ns("//#{tag}"))
           .each_with_object({ citeas: {}, bibitemid: {} }) do |i, m|
-          m[:citeas][i["citeas"]] = true
-          m[:bibitemid][i["bibitemid"]] = true
+            m[:citeas][i["citeas"]] = true
+            m[:bibitemid][i["bibitemid"]] = true
         end
       end
 
@@ -70,16 +71,35 @@ module Metanorma
           "#{val}</docidentifier>"
       end
 
-      def add_hidden_bibliography(xmldoc, refs)
-        ins = new_hidden_ref(xmldoc)
+      def add_hidden_bibliography(xml, refs, current_id = nil)
+        ins = new_hidden_ref(xml)
+        current_html = if current_id
+                         @files.get(current_id,
+                                    :outputs)&.dig(:html)
+                       else
+                         nil
+                       end
         refs.each do |k, v|
           url = @files.url(v, {})
+          url = make_relative_path(current_html, url) if current_html
           ins << <<~XML
             <bibitem id="#{k}" anchor="#{k}">#{docid_xml(v)}<uri type='citation'>#{url}</uri></bibitem>
           XML
         end
       end
 
+      def make_relative_path(from_file, to_file)
+        return to_file if to_file.nil? || to_file.to_s.empty?
+        return to_file if to_file.start_with?("http://", "https://", "#")
+
+        from_dir = File.dirname(from_file)
+        return to_file if from_dir == "."
+
+        from_path = Pathname.new(from_dir)
+        to_path = Pathname.new(to_file)
+        to_path.relative_path_from(from_path).to_s
+      end
+
       private
 
       def docid_prefix(docid)
@@ -106,14 +126,24 @@ module Metanorma
       # @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)"
+          raise ArgumentError,
+                "Need to specify formats (xml,html,pdf,pdf-portfolio,doc)"
+      end
+
+      def pdfconv(added_options)
+        flavor, taste_opts, x = pdfconv_prep
+        fonts = [taste_opts[:fonts], added_options[:fonts]].compact.flatten
+          .join(";")
+        opts = @compile_options.merge(added_options.merge(taste_opts))
+        opts[:fonts] = fonts
+        x.converter.pdf_converter(PdfOptionsNode.new(flavor, opts))
       end
 
-      def pdfconv
-        flavor = @flavor.to_sym
+      def pdfconv_prep
+        flavor = Util::taste2flavor(@flavor).to_sym
+        taste_opts = Util::taste2isodoc_attrs(@flavor, :pdf)
         x = Asciidoctor.load nil, backend: flavor
-        x.converter.pdf_converter(PdfOptionsNode.new(flavor,
-                                                     @compile_options))
+        [flavor, taste_opts, x]
       end
 
       def fail_update_bibitem(docid, identifier)
@@ -125,7 +155,7 @@ module Metanorma
 
       def datauri_encode(docxml, directory)
         docxml.xpath(ns("//image")).each do |i|
-          read_in_if_svg(i, directory.sub(%r{(?<!=/)$}, "/")) and i["src"] = nil
+          read_in_if_svg(i, directory.sub(%r{(?<!=/)$}, "/"))
         end
         docxml.xpath(ns("//image")).each do |i| # rubocop:disable Style/CombinableLoops
           i["src"] && !i["src"].empty? or next
@@ -135,34 +165,40 @@ module Metanorma
       end
 
       def read_in_if_svg(img, localdir)
-        img["src"] or return false
-        img.elements.map(&:name).include?("svg") and return true
+        img["src"] or return
+        if img.elements.map(&:name).include?("svg")
+          img["src"] = nil
+          return
+        end
         path = Vectory::Utils.svgmap_rewrite0_path(img["src"], localdir)
-        svg = svg_in_path?(path) or return false
+        svg = svg_in_path?(path) or return
         img.children = (Nokogiri::XML(svg).root)
+        img["src"] = nil
         true
       end
 
       def svg_in_path?(path)
         File.file?(path) or return false
-        types = MIME::Types.type_for(path) or return false
-        types.first == "image/svg+xml" or return false
+        type = Marcel::MimeType.for(name: path) or return false
+        type == "image/svg+xml" or return false
         svg = File.read(path, encoding: "utf-8") or return false
         svg
       end
 
       class PdfOptionsNode
         def initialize(flavor, options)
-          p = Metanorma::Registry.instance.find_processor(flavor)
+          p = Metanorma::Registry.instance.find_processor(Util::taste2flavor(flavor))
           if ::Metanorma::Util::FontistHelper.has_custom_fonts?(p, options, {})
             @fonts_manifest =
               ::Metanorma::Util::FontistHelper.location_manifest(p, options)
           end
+          @options = options
         end
 
         def attr(key)
           if key == "fonts-manifest" && @fonts_manifest
             @fonts_manifest
+          else @options[key.to_sym]
           end
         end
       end
@@ -194,7 +230,7 @@ module Metanorma
         end.doc.root.to_html
       end
 
-      def eref2link(docxml, presxml)
+      def eref2link(docxml, _presxml)
         isodoc = IsoDoc::PresentationXMLConvert.new({})
         isodoc.bibitem_lookup(docxml)
         isodoc.eref2link(docxml)

data/lib/metanorma/collection/sectionsplit/collection.rb

@@ -39,24 +39,33 @@ module Metanorma
       end
 
       def collectionyaml(files, xml)
-        #warn xml.to_xml
         ret = {
           directives: ["presentation-xml", "bare-after-first"],
           bibdata: {
             title: {
               type: "title-main", language: @lang,
-              content: xml.at(ns("//bibdata/title")).text
+              content: xml.at(ns("//bibdata/title"))&.text || "[TITLE]"
             },
             type: "collection",
             docid: {
-              type: xml.at(ns("//bibdata/docidentifier/@type")).text,
-              id: xml.at(ns("//bibdata/docidentifier")).text,
+              type: xml.at(ns("//bibdata/docidentifier/@type"))&.text || "[FLAVOR]",
+              id: xml.at(ns("//bibdata/docidentifier"))&.text || "[DOCID]",
             },
           },
           manifest: {
             level: "collection", title: "Collection",
             docref: files.sort_by { |f| f[:order] }.each.map do |f|
-              { fileref: f[:url], identifier: f[:title] }
+              # XML files are always stored flat, so fileref is always the basename
+              # f[:url] may include directory for HTML output, but XML is basename only
+              fileref = File.basename(f[:url])
+              entry = { fileref: fileref, identifier: f[:title] }
+              # Include sectionsplit_filename and sectionsplit-output when there's a directory structure
+              # This tells the renderer to preserve directory structure in HTML output
+              if @sectionsplit_filename && File.dirname(@sectionsplit_filename) != "."
+                entry[:"sectionsplit-filename"] = @sectionsplit_filename
+                entry[:"sectionsplit-output"] = true
+              end
+              entry
             end
           },
         }

data/lib/metanorma/collection/sectionsplit/sectionsplit.rb

@@ -1,4 +1,5 @@
 require "yaml"
+require "fileutils"
 require_relative "../../util/util"
 require_relative "../xrefprocess/xrefprocess"
 require_relative "collection"
@@ -21,6 +22,9 @@ module Metanorma
         @isodoc = opts[:isodoc]
         @isodoc_presxml = opts[:isodoc_presxml]
         @document_suffix = opts[:document_suffix]
+        @sectionsplit_filename = opts[:sectionsplit_filename] ||
+          "{basename_legacy}.{sectionsplit-num}"
+        @parent_idx = opts[:parent_idx] || 0
       end
 
       def ns(xpath)
@@ -49,6 +53,7 @@ module Metanorma
       def sectionsplit1(xml, empty, empty1, idx)
         ret = SPLITSECTIONS.each_with_object([]) do |n, m|
           conflate_floatingtitles(xml.xpath(ns(n[0]))).each do |s|
+            # require "debug"; binding.b
             sectionsplit2(xml, idx.zero? ? empty : empty1, s, n[1],
                           { acc: m, idx: idx })
             idx += 1
@@ -61,8 +66,13 @@ module Metanorma
 
       def sectionsplit2(xml, empty, chunks, parentnode, opt)
         @pool.post do
-          warn "#{@base}.#{opt[:idx]}"
-          a = sectionfile(xml, empty, "#{@base}.#{opt[:idx]}", chunks,
+          output_filename = @sectionsplit_filename
+            &.gsub(/\{document-num\}/, @parent_idx.to_s)
+            &.gsub(/\{basename_legacy\}/, @base)
+            &.gsub(/\{basename\}/, File.basename(@base, ".*"))
+            &.gsub(/\{sectionsplit-num\}/, opt[:idx].to_s)
+          warn "Sectionsplit: #{output_filename}"
+          a = sectionfile(xml, empty, output_filename, chunks,
                           parentnode)
           @mutex.synchronize { opt[:acc] << a }
         end
@@ -154,11 +164,14 @@ module Metanorma
         sectionfile_fn_filter(sectionfile_annotation_filter(out))
         Metanorma::Collection::XrefProcess::xref_process(out, xml, @key,
                                                          @ident, @isodoc, true)
-        outname = "#{file}.xml"
-        File.open(File.join(@splitdir, outname), "w:UTF-8") do |f|
-          f.write(out)
-        end
-        outname
+        # XML files are always written flat to the splitdir (_files directory)
+        # Directory structure from sectionsplit_filename is only used for HTML output
+        xml_filename = "#{File.basename(file)}.xml"
+        full_path = File.join(@splitdir, xml_filename)
+        File.open(full_path, "w:UTF-8") { |f| f.write(out) }
+        # Return full file path (with directory) for use in manifest
+        # This preserves directory info for HTML rendering without affecting XML storage
+        "#{file}.xml"
       end
 
       def sectionfile_insert(ins, chunks, parentnode)

data/lib/metanorma/collection/util/disambig_files.rb

@@ -10,13 +10,12 @@ module Metanorma
           name.sub(%r{^(\./)?(\.\./)+}, "")
         end
 
-        def source2dest_filename(name, disambig = true)
+        def source2dest_filename(name, disambig: true, preserve_dirs: false)
           n = strip_root(name)
-          dir = File.dirname(n)
-          base = File.basename(n)
-          if disambig && @seen_filenames.include?(base)
+          dir = preserve_dirs ? "." : File.dirname(n)
+          base = preserve_dirs ? n : File.basename(n)
+          disambig && @seen_filenames.include?(base) and
             base = disambiguate_filename(base)
-          end
           @seen_filenames << base
           dir == "." ? base : File.join(dir, base)
         end

data/lib/metanorma/collection/util/util.rb

@@ -1,7 +1,14 @@
+require "marcel"
+
 module Metanorma
   class Collection
     module Util
       class << self
+        def mime_file_recognised?(filename)
+          mime_type = Marcel::MimeType.for name: filename
+          mime_type != "application/octet-stream"
+        end
+
         def anchor_id_attributes
           Metanorma::Utils::anchor_attributes(presxml: true) +
             [%w(* id), %w(* anchor), %w(link bibitemid), %w(fmt-link bibitemid)]
@@ -9,12 +16,13 @@ module Metanorma
 
         def gather_bibitems(xml)
           xml.xpath("//xmlns:bibitem[@id]").each_with_object({}) do |b, m|
-            if m[b["id"]]
+            id = b["anchor"] || b["id"]
+            if m[id]
               b.remove
               next
               # we can't update duplicate bibitem, processing updates wrong one
             else
-              m[b["id"]] = b
+              m[id] = b
             end
           end
         end
@@ -36,12 +44,14 @@ module Metanorma
           end
         end
 
-        def add_suffix_to_attrs(doc, suffix, tag_name, attr_name, isodoc)
+        # Skip SVGs, they are processed by Vectory::SvgDocument#suffix_ids
+        def add_suffix_to_attrs(doc, suffix, tag, attr, isodoc)
           (suffix.nil? || suffix.empty?) and return
-          doc.xpath(isodoc.ns("//#{tag_name}[@#{attr_name}]")).each do |elem|
-            a = elem.attributes[attr_name].value
+          doc.xpath(isodoc.ns("//#{tag}[@#{attr}][not(ancestor-or-self::*[local-name()='svg'])]")).each do |elem|
+            # doc.xpath(isodoc.ns("//#{tag}[@#{attr}]")).each do |elem|
+            a = elem.attributes[attr].value
             /_#{suffix}$/.match?(a) or
-              elem.attributes[attr_name].value = "#{a}_#{suffix}"
+              elem.attributes[attr].value = "#{a}_#{suffix}"
           end
         end
 
@@ -71,6 +81,81 @@ module Metanorma
           @c.decode(ident).gsub(/(\p{Zs})+/, " ")
         end
 
+        def taste2flavor(taste)
+          tastes = Metanorma::TasteRegister.instance.aliases
+          tastes[taste.to_sym] and taste = tastes[taste.to_sym]
+          taste
+        end
+
+        def taste2isodoc_attrs(taste, format)
+          tastes = Metanorma::TasteRegister.instance.aliases
+          tastes[taste.to_sym] or return {}
+          Metanorma::TasteRegister.isodoc_attrs(taste.to_sym, format)
+        end
+
+        def taste2coverpage_pdf_portfolio(taste)
+          tastes = Metanorma::TasteRegister.instance.aliases
+          tastes[taste.to_sym] or return nil
+          taste = Metanorma::TasteRegister.instance.get(taste.to_sym)
+          ret = taste.config.base_override&.filename_attributes
+            &.coverpage_pdf_portfolio or return
+          File.join(taste.directory, ret)
+        end
+
+        SVG_NS = "http://www.w3.org/2000/svg".freeze
+
+        # update relative URLs, url(#...), in CSS in @style attrs (incl. SVG),
+        # and in include SVG url(#..) attrs,
+        # not processed already by add_suffix_to_attrs
+        def url_in_css_styles(doc, ids, document_suffix)
+          update_ids_css(doc.root, ids, document_suffix)
+          doc.xpath("//i:svg", "i" => SVG_NS).each do |s|
+            svg = Vectory::SvgDocument.new(s.to_xml)
+            svg.suffix_ids(document_suffix)
+          end
+        end
+
+        # replicates Vectory update_ids_css, but skips over svgs,
+        # which are processed separately by Vectory::SvgDocument#suffix_ids
+        def update_ids_css(document, ids, suffix)
+          suffix = suffix.is_a?(Integer) ? sprintf("%09d", suffix) : suffix
+          document.xpath(".//m:style[not(ancestor::i:svg)]",
+                         "m" => SVG_NS, "i" => SVG_NS).each do |s|
+            s.children = update_ids_css_string(s.children.to_xml, ids, suffix)
+          end
+          document.xpath(".//*[@style][not(ancestor::i:svg)]",
+                         "i" => SVG_NS).each do |s|
+            s["style"] = update_ids_css_string(s["style"], ids, suffix)
+          end
+        end
+
+        # Updates ID references in a CSS style string.
+        # Replicates Vectory update_ids_css_string
+        def update_ids_css_string(style, ids, suffix)
+          ids.each do |i|
+            style = style.gsub(%r[##{i}\b],
+                               sprintf("#%<id>s_%<suffix>s", id: i,
+                                                             suffix: suffix))
+              .gsub(%r(\[id\s*=\s*['"]?#{i}['"]?\]),
+                    sprintf("[id='%<id>s_%<suffix>s']", id: i,
+                                                        suffix: suffix))
+          end
+          style
+        end
+
+        #           doc.xpath("//*[@style]").each do |s|
+        #             s["style"] = url_in_css_styles1(s["style"], document_suffix)
+        #           end
+        #           doc.xpath("//i:svg//i:style", "i" => "http://www.w3.org/2000/svg")
+        #             .each do |s|
+        #               s.children = url_in_css_styles1(s.text, document_suffix)
+        #           end
+        #
+        #         # KILL
+        #         def url_in_css_styles1(style, document_suffix)
+        #           style.gsub(%r{url\(#([^()]+)\)}, "url(#\\1_#{document_suffix})")
+        #         end
+
         class Dummy
           def attr(_key); end
         end
@@ -94,6 +179,21 @@ module Metanorma
           isodoc.info(xml, nil)
           isodoc
         end
+
+        def asciidoc_dummy_header
+          <<~DUMMY
+            = X
+            A
+
+          DUMMY
+        end
+
+        def nokogiri_to_temp(xml, filename, suffix)
+          file = Tempfile.new([filename, suffix])
+          file.write(xml.to_xml(indent: 0))
+          file.close
+          [file, file.path]
+        end
       end
     end
   end

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

@@ -36,7 +36,7 @@ module Metanorma
         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)
+            m = svgmap_wrap(s) or next
             svg_xrefs(s, m, suffix, presxml)
           end
           xml
@@ -44,7 +44,7 @@ module Metanorma
 
         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

data/lib/metanorma/compile/compile_options.rb

@@ -123,8 +123,9 @@ module Metanorma
       def copy_isodoc_options_attrs(options, ret)
         ret[:datauriimage] = true if options[:datauriimage]
         ret[:sourcefilename] = options[:filename]
-        %i(bare sectionsplit install_fonts baseassetpath aligncrosselements
-           tocfigures toctables tocrecommendations strict)
+        %i(bare sectionsplit sectionsplit_filename install_fonts baseassetpath
+           aligncrosselements tocfigures toctables tocrecommendations strict
+           fonts)
           .each { |x| ret[x] ||= options[x] }
       end
 

data/lib/metanorma/compile/flavor.rb

@@ -7,17 +7,24 @@ module Metanorma
       # @param stdtype [Symbol] the standard type
       # @return [void]
       def load_flavor(stdtype)
-        stdtype = stdtype.to_sym
-        flavor = stdtype2flavor_gem(stdtype)
-        @registry.supported_backends.include? stdtype or
+        new_stdtype = taste2flavor(stdtype)
+        flavor = stdtype2flavor_gem(new_stdtype)
+        @registry.supported_backends.include? new_stdtype or
           Util.log("[metanorma] Info: Loading `#{flavor}` gem "\
                    "for standard type `#{stdtype}`.", :info)
         require_flavor(flavor)
-        @registry.supported_backends.include? stdtype or
+        @registry.supported_backends.include? new_stdtype or
           Util.log("[metanorma] Error: The `#{flavor}` gem does not "\
                    "support the standard type #{stdtype}. Exiting.", :fatal)
       end
 
+      def taste2flavor(stdtype)
+        stdtype = stdtype.to_sym
+        tastes = Metanorma::TasteRegister.instance.aliases
+        tastes[stdtype] and stdtype = tastes[stdtype].to_sym
+        stdtype
+      end
+
       # Convert the standard type to the flavor gem name
       # @param stdtype [Symbol] the standard type
       # @return [String] the flavor gem name

data/lib/metanorma/compile/render.rb

@@ -159,6 +159,7 @@ module Metanorma
       ::Metanorma::Collection::Sectionsplit.new(
         input: input_filename, isodoc: @isodoc, xml: presxml,
         base: File.basename(output_filename || filename),
+        sectionsplit_filename: opts[:sectionsplit_filename],
         output: output_filename || filename, dir: dir, compile_opts: opts
       ).build_collection
     end

data/lib/metanorma/version.rb

@@ -1,3 +1,3 @@
 module Metanorma
-  VERSION = "2.3.0".freeze
+  VERSION = "2.3.2".freeze
 end

data/metanorma.gemspec

@@ -26,27 +26,17 @@ Gem::Specification.new do |spec|
 
   spec.add_runtime_dependency "asciidoctor"
   spec.add_runtime_dependency "concurrent-ruby"
-  spec.add_runtime_dependency "fontist", ">= 2.0.0"
+  spec.add_runtime_dependency "fontist", ">= 2.1.2"
   spec.add_runtime_dependency "htmlentities"
   spec.add_runtime_dependency "isodoc", ">= 3.0.0"
-  spec.add_runtime_dependency "metanorma-taste", "~> 0.1.0"
+  spec.add_runtime_dependency "marcel"
+  spec.add_runtime_dependency "metanorma-taste", "~> 1.0.0"
   spec.add_runtime_dependency "mn2pdf", "~> 2"
   spec.add_runtime_dependency "nokogiri"
+  spec.add_development_dependency "canon", "= 0.1.3"
+  spec.add_development_dependency "metanorma-iho"
+  spec.add_development_dependency "metanorma-iso"
 
   # relaton-cli is required by Metanorma::Collection
   spec.add_dependency "relaton-cli"
-
-  spec.add_development_dependency "debug"
-  spec.add_development_dependency "equivalent-xml"
-  spec.add_development_dependency "metanorma-iso", ">= 3.2.0"
-  spec.add_development_dependency "mnconvert"
-  spec.add_development_dependency "pry"
-  spec.add_development_dependency "rake", "~> 13.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-  spec.add_development_dependency "rspec-command", "~> 1.0"
-  spec.add_development_dependency "rubocop", "~> 1"
-  spec.add_development_dependency "rubocop-performance"
-  spec.add_development_dependency "sassc-embedded", "~> 1"
-  spec.add_development_dependency "simplecov", "~> 0.15"
-  spec.add_development_dependency "canon", "= 0.1.3"
 end