metanorma 2.4.3 → 2.5.1

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

@@ -17,10 +17,36 @@ module Metanorma
     class Renderer
       FORMATS = %i[html xml doc pdf pdf-portfolio].freeze
 
-      attr_accessor :isodoc, :isodoc_presxml, :nested
+      attr_accessor :isodoc, :isodoc_presxml
       attr_reader :xml, :compile, :compile_options, :documents, :outdir,
                   :manifest
 
+      # Run the block with the renderer in nested mode, restoring the previous
+      # mode afterwards. Nested mode (used by sectionsplit, which re-enters this
+      # renderer's update_xrefs on the pre-split document) preserves unresolved
+      # erefs and skips the finalising reference passes.
+      def with_nested
+        saved = @nested
+        @nested = true
+        yield
+      ensure
+        @nested = saved
+      end
+
+      # Run the block with the renderer preserving unresolved cross-document
+      # references as stubs instead of stripping them -- for an isolated build of
+      # a collection member (compiled without the rest of its collection
+      # present). Unlike +with_nested+, the ordinary intra-document passes still
+      # run (xref_process, svgmap); only the cross-document resolve/strip is
+      # turned into preserve, so a later reinflation pass can relink the stubs.
+      def with_preserve_unresolved
+        saved = @preserve_unresolved
+        @preserve_unresolved = true
+        yield
+      ensure
+        @preserve_unresolved = saved
+      end
+
       # This is only going to render the HTML collection
       # @param xml [Metanorma::Collection] input XML collection
       # @param folder [String] input folder
@@ -71,6 +97,31 @@ module Metanorma
         # if false, this is the root instance of Renderer
         # if true, then this is not the last time Renderer will be run
         # (e.g. this is sectionsplit)
+        # Isolated/incremental build: preserve unresolved cross-document
+        # references as stubs instead of resolving or stripping them, so each
+        # member compiles independently and a later reinflation pass relinks.
+        @preserve_unresolved = options[:preserve_unresolved]
+        # Durable content-addressed store for staged artefacts. Opt-in: a plain
+        # build sets neither :preserve_unresolved nor :artifact_store_dir, so it
+        # gets the no-op Null store and is unaffected. Staging (:preserve_unresolved)
+        # defaults the store directory to ArtifactStore::DEFAULT_DIRNAME when no
+        # :artifact_store_dir is given, so callers need not name it. (Reinflation
+        # reads stored stubs via the manifest, not this object, so it does not
+        # trigger the default -- that would only create an empty directory.)
+        @artifact_store =
+          if (dir = options[:artifact_store_dir]) || options[:preserve_unresolved]
+            ArtifactStore.new(dir || ArtifactStore::DEFAULT_DIRNAME)
+          else
+            NullArtifactStore.new
+          end
+        # Reinflation pass: the input is a stored stub-bearing Semantic XML that
+        # already has intra-doc xrefs and the document suffix applied, so run
+        # only the cross-document resolution, not the passes already done.
+        @reinflate = options[:reinflate]
+        # Cache retention: by default keep only each document's latest artefacts,
+        # pruning superseded content-hash versions on write; keep_cache retains
+        # every version (history / multiple states side by side).
+        @keep_cache = options[:keep_cache]
 
         @coverpage = options[:coverpage] || collection.coverpage
         @coverpage_pdf_portflio = options[:coverpage_pdf_portfolio] ||
@@ -90,21 +141,6 @@ module Metanorma
         directives_normalise_keystore_pdf_portfolio(directives)
       end
 
-      # KILL
-      def directives_normalise_coverpage_pdf_portfolio(directives)
-        directives.reject! { |d| d.key == "coverpage-pdf-portfolio" }
-        absolute_coverpage_pdf_portflio = @coverpage_pdf_portflio &&
-          Pathname.new(@coverpage_pdf_portflio).absolute?
-        @coverpage_pdf_portflio =
-          Util::rel_path_resolve(@dirname, @coverpage_pdf_portflio)
-        absolute_coverpage_pdf_portflio or
-          @coverpage_pdf_portflio = Pathname.new(@coverpage_pdf_portflio)
-            .relative_path_from(Pathname.new(@outdir)).to_s
-        directives << ::Metanorma::Collection::Config::Directive
-          .new(key: "coverpage-pdf-portfolio", value: @coverpage_pdf_portflio)
-        directives
-      end
-
       def directives_normalise_coverpage_pdf_portfolio(directives)
         directives_resolve_filepath(directives, "coverpage-pdf-portfolio",
                                     @coverpage_pdf_portflio)
@@ -258,10 +294,22 @@ module Metanorma
           .new(key: "documents-inline")
         out.bibdatas.each_key do |ident|
           id = @isodoc.docid_prefix(nil, ident.dup)
-          @files.get(id, :attachment) || @files.get(id, :outputs).nil? and next
+          @files.get(id, :attachment) and next
+          # A non-attachment document with no compiled output for THIS format
+          # cannot be inlined: leaving it in place serialises as a bibdata-only,
+          # namespace-less <metanorma> that mn2pdf silently drops. Skip loudly
+          # rather than crash on a nil path or corrupt the collection PDF.
+          # (Sectionsplit parents get a :presentation output upstream, so they
+          # inline whole for the PDF/presentation path.)
+          outputs = @files.get(id, :outputs)
+          if outputs.nil? || outputs[ext].nil?
+            warn "[metanorma] collection document '#{id}' has no compiled " \
+                 "#{ext} output to inline; skipping (its doc-container would " \
+                 "otherwise be bibdata-only)."
+            next
+          end
           out.documents[Util::key id] =
-            Metanorma::Collection::Document
-              .raw_file(@files.get(id, :outputs)[ext])
+            Metanorma::Collection::Document.raw_file(outputs[ext])
         end
         out
       end

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

@@ -7,8 +7,24 @@ require "concurrent-ruby"
 
 module Metanorma
   class Collection
+    # Sectionsplit is a collection render nested inside a collection render:
+    # a document is split into one output file per section, and those files are
+    # then rendered as their own (sub-)collection.
+    #
+    # Two output-location invariants matter (both load-bearing -- see the
+    # collection architecture review plan and metanorma/iso-10303#208):
+    #
+    # * XML section files are always written FLAT to the split directory
+    #   (basename only). HTML output may instead carry a directory taken from
+    #   sectionsplit_filename, reattached only at HTML compile time
+    #   (preserve_directory_structure?).
+    # * A sectionsplit document's content is emitted at the sectionsplit output
+    #   location (the collection root, unless sectionsplit_filename sets a
+    #   directory), NOT at the document's own :out_path. Anything relativising a
+    #   URL for such a document (e.g. attachment/citation links) must base it on
+    #   the split location, or the ../../ overshoots.
     class Sectionsplit
-      attr_accessor :filecache, :key
+      attr_accessor :filecache, :key, :whole_presentation_file
 
       def initialize(opts)
         @input_filename = opts[:input]
@@ -40,6 +56,13 @@ module Metanorma
       # Input XML is Semantic XML
       def sectionsplit
         xml = sectionsplit_prep(File.read(@input_filename), @base, @dir)
+        # Retain the whole (un-split) Presentation XML. sectionsplit is an
+        # HTML-only mechanism, but the collection PDF/presentation path must
+        # inline each document intact; without this the sectionsplit parent
+        # reaches concatenation with no presentation output and degrades to a
+        # bibdata-only, namespace-less <metanorma> stub that mn2pdf drops.
+        # https://github.com/metanorma/iso-10303/issues/208
+        @whole_presentation_file = write_whole_presentation(xml)
         @key = Metanorma::Collection::XrefProcess::xref_preprocess(xml, @isodoc)
         empty = empty_doc(xml)
         empty1 = empty_attachments(empty)
@@ -66,11 +89,11 @@ module Metanorma
 
       def sectionsplit2(xml, empty, chunks, parentnode, opt)
         @pool.post do
-          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)
+          output_filename = Util.substitute_filename_pattern(
+            @sectionsplit_filename,
+            document_num: @parent_idx, basename: File.basename(@base, ".*"),
+            basename_legacy: @base, sectionsplit_num: opt[:idx]
+          )
           warn "Sectionsplit: #{output_filename}"
           a = sectionfile(xml, empty, output_filename, chunks,
                           parentnode)
@@ -108,6 +131,16 @@ module Metanorma
         r
       end
 
+      # Persist the whole, svgmap-restored Presentation XML (the in-memory doc,
+      # not the on-disk tmp which still carries the internal svgmap1 marker) so
+      # the collection PDF path can inline the document whole. Written flat to
+      # the split output directory, where the per-section files also live.
+      def write_whole_presentation(xml)
+        fname = File.join(@splitdir, "#{@base}.whole.presentation.xml")
+        File.write(fname, xml.to_xml, encoding: "UTF-8")
+        fname
+      end
+
       def sectionsplit_preprocess_semxml(file, filename)
         xml = Nokogiri::XML(file, &:huge)
         type = xml.root["flavor"]
@@ -120,10 +153,8 @@ module Metanorma
 
       def sectionsplit_update_xrefs(xml)
         if c = @fileslookup&.parent
-          n = c.nested
-          c.nested = true # so unresolved erefs are not deleted
-          c.update_xrefs(xml, @ident, {})
-          c.nested = n
+          # nested mode so unresolved erefs are not deleted
+          c.with_nested { c.update_xrefs(xml, @ident, {}) }
           xml.xpath("//xmlns:svgmap").each { |x| x.name = "svgmap1" }
           # do not process svgmap until after files are split
         end

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

@@ -81,6 +81,22 @@ module Metanorma
           @c.decode(ident).gsub(/(\p{Zs})+/, " ")
         end
 
+        # Substitute special strings in filename patterns. Single source for
+        # both FileLookup#substitute_filename_pattern and sectionsplit.
+        # @param pattern [String] filename pattern with placeholders
+        # @param options [Hash] substitution values:
+        #   :document_num, :basename, :basename_legacy, :sectionsplit_num
+        def substitute_filename_pattern(pattern, options = {})
+          pattern or return pattern
+          subs = { "{document-num}" => options[:document_num],
+                   "{basename}" => options[:basename],
+                   "{basename_legacy}" => options[:basename_legacy],
+                   "{sectionsplit-num}" => options[:sectionsplit_num] }
+          subs.each_with_object(pattern.dup) do |(token, val), result|
+            val and result.gsub!(token, val.to_s)
+          end
+        end
+
         def taste2flavor(taste)
           tastes = Metanorma::TasteRegister.instance.aliases
           tastes[taste.to_sym] and taste = tastes[taste.to_sym]

data/lib/metanorma/version.rb

@@ -1,3 +1,3 @@
 module Metanorma
-  VERSION = "2.4.3".freeze
+  VERSION = "2.5.1".freeze
 end

data/metanorma.gemspec

@@ -22,7 +22,7 @@ Gem::Specification.new do |spec|
   spec.bindir        = "bin"
   # spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
-  spec.required_ruby_version = ">= 3.1.0"
+  spec.required_ruby_version = Gem::Requirement.new(">= 3.3.0")
 
   spec.add_runtime_dependency "asciidoctor"
   spec.add_runtime_dependency "concurrent-ruby"