suma 0.5.19 → 0.5.20

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: df03b41b1c8ad66d68f1f6bb711f9cc49396e1b9217b2819eef5f1a9ae98b997
-  data.tar.gz: 04f0d313dbe23ce6579b0c2736d264c7934dcc250a84c9e55f8bc39014e50a8e
+  metadata.gz: 467b9bcc21844daaac8a68fdb76b15b9e165b6fd2243d469282f44d15f69cb97
+  data.tar.gz: 4714dc0a4e2b9b8f63f4cdb5a88db33401662633f15fb7669c3c18908dc77492
 SHA512:
-  metadata.gz: 1eb98f1e8d9cd8ead0c40db5867929d74a50d440cd964848a0fbafaac2b23e0ad0d484522cc98a1ea5afc9c4cf88137ed8670af848088059c37c0c718da2dfdc
-  data.tar.gz: 85bf0f0ea57ac912398b33264550a89f7b0118cac0b76f7a239cc33b49a78d39d9e535abdeb6a801022fb462dabb02727bbc38a055ee99b9f7ac7a88e50b8afe
+  metadata.gz: 4a2a42ab57f4d4cec318dd6232e604ae9081402d66372437abd3854efa435ad87fddd43e91fd0da24156584bfc652174b36930cc7d30b00fb727857b9cd3e66a
+  data.tar.gz: 69822cae107459997e8ebb80499fc6f8058f8e396949a33e8971b2cc6802ffbabe1f221f51c3b132b5c32170f965920363c5f61da3d6f7d3ae49e27a1a5b0ecb

data/lib/suma/staged_collection_builder.rb

@@ -3,6 +3,7 @@
 require "metanorma"
 require "yaml"
 require "fileutils"
+require "pathname"
 
 module Suma
   # Memory-bounded, resumable staged collection build (metanorma/suma#94).
@@ -73,7 +74,7 @@ module Suma
       staged = shard_members(members)
       Utils.log shard_log(staged.size, members.size)
       if @workers == 1
-        staged.each_with_index { |member, i| stage_member(member, i) }
+        unstaged_members(staged).each_with_index { |member, i| stage_member(member, i) }
       else
         stage_parallel(staged)
       end
@@ -104,6 +105,19 @@ module Suma
         "skipping reinflate"
     end
 
+    # Members already present in the store (their docref-slug artefact
+    # exists) are not re-rendered: an interrupted or repeated build over
+    # a warm store goes straight to reinflate, so the assembly pass costs
+    # minutes instead of re-rendering the whole collection.
+    def unstaged_members(members)
+      members.reject do |member|
+        identifier = member["identifier"]
+        stored = identifier && stored_semantic(identifier)
+        Utils.log "[staged] stored, skipping #{identifier}" if stored
+        stored
+      end
+    end
+
     # Batch the members and run +@workers+ renderer child processes
     # concurrently. Each batch file carries fully-rendered single-member
     # manifests; children claim batches through O_EXCL markers, so a slow
@@ -113,7 +127,7 @@ module Suma
     # identifier-keyed store entries, so concurrent children cannot race;
     # sectionsplit only happens at reinflate (a single sequential pass).
     def stage_parallel(members)
-      paths, count = write_batch_files(members)
+      paths, count = write_batch_files(unstaged_members(members))
       run_batch_workers(count)
     ensure
       remove_batch_files(paths, count)
@@ -201,15 +215,13 @@ module Suma
               # identifier; members whose document docid differs from the
               # docref (docrefs carrying metanorma's GUID marker) were
               # therefore unrecoverable ("no stored artefact"). Alias the
-              # artefacts this render produced under the docref slug too.
-              # Shape: single_member_manifest => {"manifest" =>
-              #   {"manifest" => [{"docref" => [dr]}]}}.
+              # artefacts keyed by the render's own bibdata keys under the
+              # docref slug too. Shape: single_member_manifest =>
+              # {"manifest" => {"manifest" => [{"docref" => [dr]}]}}.
               member_id = manifest.dig("manifest", "manifest", 0, "docref", 0, "identifier")
               id_slug = member_id.to_s
                 .gsub(/[^A-Za-z0-9._-]+/, "-").gsub(/-{2,}/, "-")
                 .gsub(/\A-|-\z/, "")
-              semantics_before = Dir.children(store_dir)
-                .select { |f| f.end_with?(".semantic.xml") }
               compile = { install_fonts: false }
               compile[:novalid] = true if no_valid == "1"
               collection = Metanorma::Collection.parse(one_path)
@@ -219,37 +231,25 @@ module Suma
                 compile: compile,
               )
               unless id_slug.empty?
-                # A warm artefact cache makes the render a full cache hit:
-                # no new artefact files appear, so a produced-files delta
-                # never fires. The collection's own keys are what the
-                # renderer stored under, so alias every semantic artefact
-                # keyed by them to the docref slug as well.
-                store_keys = (collection.bibdatas || {}).keys
-                produced = Dir.children(store_dir).select do |f|
-                  f.end_with?(".semantic.xml")
-                end - semantics_before
-                if produced.empty?
-                  store_keys.each do |key|
-                    src_slug = key.to_s
-                      .gsub(/[^A-Za-z0-9._-]+/, "-").gsub(/-{2,}/, "-")
-                      .gsub(/\A-|-\z/, "")
-                    next if src_slug.empty? || src_slug == id_slug
-
-                    Dir[File.join(store_dir,
-                                  "#{src_slug}.*.semantic.xml")].each do |f|
-                      alias_name = f.sub(
-                        %r{/#{Regexp.escape(src_slug)}.},
-                        "/#{id_slug}.",
-                      )
-                      FileUtils.cp(f, alias_name)
-                    end
-                  end
-                end
-                produced.each do |f|
-                  if (m = f.match(/\A(.*).([0-9a-f]+).semantic.xml\z/))
-                    alias_name = "#{id_slug}.#{m[2]}.semantic.xml"
-                    alias_path = File.join(store_dir, alias_name)
-                    FileUtils.cp(File.join(store_dir, f), alias_path)
+                # Alias strictly from the collection's own bibdata keys:
+                # they are the docids this member's render stored under.
+                # A produced-files delta is not safe here - with
+                # concurrent workers another child's render lands in the
+                # shared store mid-flight, and a delta would alias other
+                # members' documents under this docref (suma#167).
+                (collection.bibdatas || {}).keys.each do |key|
+                  src_slug = key.to_s
+                    .gsub(/[^A-Za-z0-9._-]+/, "-").gsub(/-{2,}/, "-")
+                    .gsub(/\A-|-\z/, "")
+                  next if src_slug.empty? || src_slug == id_slug
+
+                  Dir[File.join(store_dir,
+                                "#{src_slug}.*.semantic.xml")].each do |f|
+                    alias_name = f.sub(
+                      %r{/#{Regexp.escape(src_slug)}.},
+                      "/#{id_slug}.",
+                    )
+                    FileUtils.cp(f, alias_name)
                   end
                 end
               end
@@ -313,21 +313,81 @@ module Suma
     end
 
     # Assemble a manifest of the stored stubs and reinflate them into the site.
+    # The original manifest tree is preserved (nested collections,
+    # attachments, per-member sectionsplit) with each member entry swapped
+    # for its stored stub; the render resolves paths against the
+    # reinflate manifest's own directory, so every path the render reads
+    # is absolutized against the collection root (suma#168, suma#169).
     def reinflate(members)
       reinf_dir = File.join(@output_directory, "_staged_reinflate")
       FileUtils.mkdir_p(reinf_dir)
       docrefs = stored_docrefs(members, reinf_dir)
+      write_reinflate_manifest(docrefs, reinf_dir)
+      run_render(manifest_path: File.join(reinf_dir, "reinflate.yml"),
+                 opts: reinflate_render_options)
+    end
+
+    def write_reinflate_manifest(docrefs, reinf_dir)
+      rebuilt = with_stubbed_members(manifest["manifest"], docrefs, [0])
       reinf_path = File.join(reinf_dir, "reinflate.yml")
       File.write(reinf_path,
-                 base_manifest.merge("manifest" => collection_manifest(docrefs)).to_yaml)
+                 base_manifest.merge("manifest" => rebuilt).to_yaml)
       Utils.log "[staged] reinflating #{docrefs.size} stored members -> " \
                 "#{@output_directory}"
-      run_render(
-        manifest_path: reinf_path,
-        opts: { format: @formats, output_folder: @output_directory,
-                reinflate: true, coverpage: @coverpage,
-                compile: compile_flags }.compact,
-      )
+    end
+
+    def reinflate_render_options
+      {
+        format: @formats,
+        output_folder: File.expand_path(@output_directory),
+        reinflate: true,
+        coverpage: @coverpage && File.expand_path(@coverpage, @config_dir),
+        compile: compile_flags,
+      }.compact
+    end
+
+    # Deep-copy the manifest tree, replacing each member entry (same
+    # predicate and pre-order as collection_members) with its stub docref,
+    # and absolutizing non-member filerefs (attachments) against the
+    # collection root.
+    def with_stubbed_members(node, docrefs, counter)
+      case node
+      when Array
+        node.map { |child| with_stubbed_members(child, docrefs, counter) }
+      when Hash
+        with_stubbed_members_hash(node, docrefs, counter)
+      else
+        node
+      end
+    end
+
+    def with_stubbed_members_hash(node, docrefs, counter)
+      rewritten = node.dup
+      rewritten.each_key do |key|
+        rewritten[key] = rewrite_entry_value(key, rewritten[key], docrefs, counter)
+      end
+      stub_for(rewritten, docrefs, counter) || rewritten
+    end
+
+    def rewrite_entry_value(key, value, docrefs, counter)
+      if %w[file fileref].include?(key) && value &&
+          !Pathname.new(value).absolute?
+        File.expand_path(value, @config_dir)
+      else
+        with_stubbed_members(value, docrefs, counter)
+      end
+    end
+
+    def stub_for(node, docrefs, counter)
+      return unless member_entry?(node)
+
+      index = counter[0]
+      counter[0] += 1
+      docrefs[index]
+    end
+
+    def member_entry?(node)
+      (node["fileref"] || node["file"]) && !truthy?(node["attachment"])
     end
 
     def compile_flags

data/lib/suma/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Suma
-  VERSION = "0.5.19"
+  VERSION = "0.5.20"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: suma
 version: !ruby/object:Gem::Version
-  version: 0.5.19
+  version: 0.5.20
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-01 00:00:00.000000000 Z
+date: 2026-11-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: expressir