uniword 1.2.5 → 1.4.0

data/lib/uniword/docx/package_serialization.rb

@@ -44,13 +44,13 @@ document_rels)
         inject_bibliography(content_types, document_rels)
         inject_custom_properties(content_types, package_rels)
         inject_custom_xml(content_types)
-        inject_headers(content_types, document_rels)
-        inject_footers(content_types, document_rels)
-        inject_header_footer_parts(content_types, document_rels)
+        inject_header_footer_content_types(content_types)
         inject_notes(content_types, document_rels)
+        inject_comments(content_types, document_rels)
         inject_theme(content_types, document_rels)
         inject_numbering(content_types, document_rels)
         inject_embeddings(content_types, document_rels)
+        inject_raw_part_content_types(content_types)
       end
 
       # Serialize all package parts to XML and add to content hash
@@ -137,13 +137,12 @@ document_rels)
         end
 
         # Notes
-        if footnotes
-          content["word/footnotes.xml"] =
-            serialize_part(footnotes)
-        end
-        if endnotes
-          content["word/endnotes.xml"] =
-            serialize_part(endnotes)
+        serialize_notes(content)
+
+        # Comments
+        if comments
+          content["word/comments.xml"] =
+            serialize_part(comments)
         end
 
         # Bibliography sources
@@ -152,13 +151,14 @@ document_rels)
             serialize_infrastructure(document.bibliography_sources)
         end
 
-        # Headers and footers
-        serialize_headers(content)
-        serialize_footers(content)
+        # Headers and footers (unified store)
         serialize_header_footer_parts(content)
 
         # OLE/embedded object binaries
         serialize_embeddings(content)
+
+        # Raw passthrough parts (unmodelled; byte-for-byte)
+        serialize_raw_parts(content)
       end
 
       # Serialize an OOXML document part with standard encoding, single-line output.
@@ -183,340 +183,251 @@ document_rels)
 
       private
 
-      # Generate the next numeric relationship ID for a Relationships object.
-      def next_rid(relationships)
-        Ooxml::Relationships::PackageRelationships.next_available_rid(
-          relationships,
-        )
-      end
-
-      # Shared pattern: ensure a part has both a content type override and
-      # a document relationship. Idempotent — skips if already present.
-      # When allocator is present, only adds content type (rels handled by allocator).
-      def ensure_content_type(content_types, rels, part_name:,
-                              content_type:, rel_type:, target:)
-        unless content_types.overrides.any? { |o| o.part_name == part_name }
-          content_types.overrides << Uniword::ContentTypes::Override.new(
-            part_name: part_name, content_type: content_type,
-          )
-        end
-
-        return if allocator
-        return if rels.relationships.any? { |r| r.target == target }
+      # Shared pattern: ensure a part has a content type override.
+      # Idempotent — skips if already present. Relationships are owned
+      # by the Reconciler (assembled from the IdAllocator), never by
+      # the serializer. Part metadata comes from Ooxml::PartRegistry.
+      def ensure_content_type(content_types, definition)
+        part_name = definition.part_name
+        return if content_types.overrides.any? { |o| o.part_name == part_name }
 
-        rels.relationships << Ooxml::Relationships::Relationship.new(
-          id: next_rid(rels), type: rel_type, target: target,
+        content_types.overrides << Uniword::ContentTypes::Override.new(
+          part_name: part_name, content_type: definition.content_type,
         )
       end
 
       # Legacy alias — calls ensure_content_type (same behavior)
       alias ensure_part_registered ensure_content_type
 
-      def inject_image_parts(content, content_types, document_rels)
+      def inject_image_parts(content, content_types, _document_rels)
         return unless document&.image_parts && !document.image_parts.empty?
 
-        document.image_parts.each_value do |image_data|
-          ext = File.extname(image_data[:target]).delete(".")
+        document.image_parts.each_value do |part|
+          ext = File.extname(part.target.to_s).delete(".")
           next if content_types.defaults.any? { |d| d.extension == ext }
 
           content_types.defaults << Uniword::ContentTypes::Default.new(
-            extension: ext, content_type: image_data[:content_type],
+            extension: ext, content_type: part.content_type,
           )
         end
 
-        document.image_parts.each_value do |image_data|
-          content["word/#{image_data[:target]}"] = image_data[:data]
-        end
-
-        return if allocator
-
-        document.image_parts.each do |r_id, image_data|
-          next if document_rels.relationships.any? { |r| r.target == image_data[:target] }
-
-          document_rels.relationships << Ooxml::Relationships::Relationship.new(
-            id: r_id,
-            type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image",
-            target: image_data[:target],
-          )
+        document.image_parts.each_value do |part|
+          content["word/#{part.target}"] = part.data
         end
       end
 
-      def inject_chart_parts(content, content_types, document_rels)
+      def inject_chart_parts(content, content_types, _document_rels)
         return unless document&.chart_parts && !document.chart_parts.empty?
 
+        chart = Ooxml::PartRegistry.find_by_key(:chart)
         unless content_types.overrides.any? do |o|
           o.part_name&.start_with?("/word/charts/")
         end
           content_types.overrides << Uniword::ContentTypes::Override.new(
-            part_name: "/word/charts/chart1.xml",
-            content_type: "application/vnd.openxmlformats-officedocument.drawingml.chart+xml",
+            part_name: chart.part_name_for(n: 1),
+            content_type: chart.content_type,
           )
         end
 
-        document.chart_parts.each do |r_id, chart_data|
-          content["word/#{chart_data[:target]}"] = chart_data[:xml]
-          document_rels.relationships << Ooxml::Relationships::Relationship.new(
-            id: r_id,
-            type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/chart",
-            target: chart_data[:target],
-          )
+        document.chart_parts.each_value do |part|
+          content["word/#{part.target}"] = part.xml
         end
       end
 
-      def inject_bibliography(content_types, document_rels)
+      def inject_bibliography(content_types, _document_rels)
         return unless document&.bibliography_sources
 
-        ensure_content_type(content_types, document_rels,
-                            part_name: "/word/sources.xml",
-                            content_type: "application/vnd.openxmlformats-officedocument.bibliography+xml",
-                            rel_type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/bibliography",
-                            target: "sources.xml")
+        ensure_content_type(content_types,
+                            Ooxml::PartRegistry.find_by_key(:bibliography))
       end
 
       def inject_custom_properties(content_types, package_rels)
         return unless custom_properties && !custom_properties.properties.empty?
 
+        definition = Ooxml::PartRegistry.find_by_key(:custom_properties)
         unless content_types.overrides.any? do |o|
-          o.part_name == "/docProps/custom.xml"
+          o.part_name == definition.part_name
         end
           content_types.overrides << Uniword::ContentTypes::Override.new(
-            part_name: "/docProps/custom.xml",
-            content_type: "application/vnd.openxmlformats-officedocument.custom-properties+xml",
+            part_name: definition.part_name,
+            content_type: definition.content_type,
           )
         end
 
         return if package_rels.relationships.any? do |r|
-          r.type.to_s.include?("officeDocument/2006/relationships/custom-properties")
+          r.type.to_s.include?(definition.rel_type)
         end
 
+        # The reconciler runs before injection; register the rId with
+        # the allocator (single authority) and append the rel here.
         package_rels.relationships << Ooxml::Relationships::Relationship.new(
-          id: next_rid(package_rels),
-          type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties",
-          target: "docProps/custom.xml",
+          id: allocator.alloc_rid(target: definition.target,
+                                  type: definition.rel_type,
+                                  scope: :package),
+          type: definition.rel_type,
+          target: definition.target,
         )
       end
 
       def inject_custom_xml(content_types)
         return unless custom_xml_items && !custom_xml_items.empty?
 
+        props = Ooxml::PartRegistry.find_by_key(:custom_xml_item_props)
         custom_xml_items.each do |item|
           idx = item[:index]
+          part_name = props.part_name_for(index: idx)
           next if content_types.overrides.any? do |o|
-            o.part_name == "/customXml/itemProps#{idx}.xml"
+            o.part_name == part_name
           end
 
           content_types.overrides << Uniword::ContentTypes::Override.new(
-            part_name: "/customXml/itemProps#{idx}.xml",
-            content_type: "application/vnd.openxmlformats-officedocument.customXmlProperties+xml",
-          )
-        end
-      end
-
-      def inject_headers(content_types, document_rels)
-        return unless document&.headers && !document.headers.empty?
-
-        counter = 0
-        document.headers.each_key do |type|
-          counter += 1
-          target = "header#{counter}.xml"
-
-          unless content_types.overrides.any? { |o| o.part_name == "/word/#{target}" }
-            content_types.overrides << Uniword::ContentTypes::Override.new(
-              part_name: "/word/#{target}",
-              content_type: "application/vnd.openxmlformats-officedocument.wordprocessingml.header+xml",
-            )
-          end
-
-          next if allocator
-          next if document_rels.relationships.any? { |r| r.target == target }
-
-          r_id = next_rid(document_rels)
-          document_rels.relationships << Ooxml::Relationships::Relationship.new(
-            id: r_id,
-            type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header",
-            target: target,
-          )
-
-          wire_header_reference(type, r_id)
-        end
-      end
-
-      def inject_footers(content_types, document_rels)
-        return unless document&.footers && !document.footers.empty?
-
-        counter = 0
-        document.footers.each_key do |type|
-          counter += 1
-          target = "footer#{counter}.xml"
-
-          unless content_types.overrides.any? { |o| o.part_name == "/word/#{target}" }
-            content_types.overrides << Uniword::ContentTypes::Override.new(
-              part_name: "/word/#{target}",
-              content_type: "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+xml",
-            )
-          end
-
-          next if allocator
-          next if document_rels.relationships.any? { |r| r.target == target }
-
-          r_id = next_rid(document_rels)
-          document_rels.relationships << Ooxml::Relationships::Relationship.new(
-            id: r_id,
-            type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer",
-            target: target,
+            part_name: part_name,
+            content_type: props.content_type,
           )
-
-          wire_footer_reference(type, r_id)
         end
       end
 
-      def inject_header_footer_parts(content_types, document_rels)
-        return unless document&.header_footer_parts && !document.header_footer_parts.empty?
+      # Register content-type overrides for every header/footer part in
+      # the unified store. Relationships and sectPr references are owned
+      # by the Reconciler (single wiring implementation); the serializer
+      # only ensures each emitted part has exactly one override.
+      def inject_header_footer_content_types(content_types)
+        parts = document&.header_footer_parts
+        return unless parts && !parts.empty?
 
-        document.header_footer_parts.each do |part|
-          part_name = "/word/#{part[:target]}"
-          unless content_types.overrides.any? { |o| o.part_name == part_name }
-            content_types.overrides << Uniword::ContentTypes::Override.new(
-              part_name: part_name,
-              content_type: part[:content_type],
-            )
-          end
+        parts.each do |part|
+          next unless part.target
 
-          next if allocator
-          next if document_rels.relationships.any? { |r| r.id == part[:r_id] }
+          part_name = "/word/#{part.target}"
+          next if content_types.overrides.any? { |o| o.part_name == part_name }
 
-          document_rels.relationships << Ooxml::Relationships::Relationship.new(
-            id: part[:r_id],
-            type: part[:rel_type],
-            target: part[:target],
+          content_types.overrides << Uniword::ContentTypes::Override.new(
+            part_name: part_name, content_type: part.content_type,
           )
         end
       end
 
-      def inject_notes(content_types, document_rels)
+      def inject_notes(content_types, _document_rels)
         if footnotes
-          ensure_content_type(content_types, document_rels,
-                              part_name: "/word/footnotes.xml",
-                              content_type: "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml",
-                              rel_type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes",
-                              target: "footnotes.xml")
+          ensure_content_type(content_types,
+                              Ooxml::PartRegistry.find_by_key(:footnotes))
         end
 
         return unless endnotes
 
-        ensure_content_type(content_types, document_rels,
-                            part_name: "/word/endnotes.xml",
-                            content_type: "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml",
-                            rel_type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes",
-                            target: "endnotes.xml")
+        ensure_content_type(content_types,
+                            Ooxml::PartRegistry.find_by_key(:endnotes))
       end
 
-      def inject_theme(content_types, document_rels)
+      def inject_theme(content_types, _document_rels)
         return unless theme
 
-        ensure_content_type(content_types, document_rels,
-                            part_name: "/word/theme/theme1.xml",
-                            content_type: "application/vnd.openxmlformats-officedocument.theme+xml",
-                            rel_type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme",
-                            target: "theme/theme1.xml")
+        ensure_content_type(content_types,
+                            Ooxml::PartRegistry.find_by_key(:theme))
+      end
+
+      def inject_comments(content_types, _document_rels)
+        return unless comments
+
+        ensure_content_type(content_types,
+                            Ooxml::PartRegistry.find_by_key(:comments))
       end
 
-      def inject_numbering(content_types, document_rels)
+      def inject_numbering(content_types, _document_rels)
         return unless numbering
 
-        ensure_content_type(content_types, document_rels,
-                            part_name: "/word/numbering.xml",
-                            content_type: "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml",
-                            rel_type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering",
-                            target: "numbering.xml")
+        ensure_content_type(content_types,
+                            Ooxml::PartRegistry.find_by_key(:numbering))
       end
 
-      def inject_embeddings(content_types, document_rels)
+      def inject_embeddings(content_types, _document_rels)
         return unless embeddings && !embeddings.empty?
 
-        embeddings.each_with_index do |(target, _data), idx|
+        ole = Ooxml::PartRegistry.find_by_key(:ole_object)
+        embeddings.each_key do |target|
           part_name = "/word/#{target}"
           next if content_types.overrides.any? { |o| o.part_name == part_name }
 
           content_types.overrides << Uniword::ContentTypes::Override.new(
             part_name: part_name,
-            content_type: "application/vnd.openxmlformats-officedocument.oleObject",
-          )
-
-          next if document_rels.relationships.any? { |r| r.target == target }
-
-          document_rels.relationships << Ooxml::Relationships::Relationship.new(
-            id: "rIdEmbedding#{idx + 1}",
-            type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/oleObject",
-            target: target,
+            content_type: ole.content_type,
           )
         end
       end
 
-      def wire_header_reference(type, r_id)
-        return unless document&.body
-
-        sect_pr = document.body.section_properties ||= Wordprocessingml::SectionProperties.new
-        existing = sect_pr.header_references&.find { |r| r.type == type }
-        if existing
-          existing.r_id = r_id
-        else
-          sect_pr.header_references << Wordprocessingml::HeaderReference.new(
-            type: type, r_id: r_id,
-          )
+      def serialize_notes(content)
+        if footnotes
+          content["word/footnotes.xml"] =
+            serialize_part(footnotes)
+        end
+        if endnotes
+          content["word/endnotes.xml"] =
+            serialize_part(endnotes)
+        end
+        if footnotes_rels
+          content["word/_rels/footnotes.xml.rels"] =
+            serialize_infrastructure(footnotes_rels)
+        end
+        if endnotes_rels
+          content["word/_rels/endnotes.xml.rels"] =
+            serialize_infrastructure(endnotes_rels)
         end
       end
 
-      def wire_footer_reference(type, r_id)
-        return unless document&.body
+      # Emit every header/footer part from the unified store: one part
+      # file per part, headers before footers (historic emission order).
+      def serialize_header_footer_parts(content)
+        parts = document&.header_footer_parts
+        return unless parts && !parts.empty?
+
+        (parts.of_kind(:header) + parts.of_kind(:footer)).each do |part|
+          next unless part.target && part.content
 
-        sect_pr = document.body.section_properties ||= Wordprocessingml::SectionProperties.new
-        existing = sect_pr.footer_references&.find { |r| r.type == type }
-        if existing
-          existing.r_id = r_id
-        else
-          sect_pr.footer_references << Wordprocessingml::FooterReference.new(
-            type: type, r_id: r_id,
-          )
+          content["word/#{part.target}"] =
+            serialize_part(part.serializable_content)
         end
       end
 
-      def serialize_headers(content)
-        return unless document&.headers && !document.headers.empty?
+      def serialize_embeddings(content)
+        return unless embeddings && !embeddings.empty?
 
-        idx = 0
-        document.headers.each_value do |header_obj|
-          idx += 1
-          content["word/header#{idx}.xml"] =
-            serialize_part(header_obj)
+        embeddings.each do |target, part|
+          content["word/#{target}"] = part.content
         end
       end
 
-      def serialize_footers(content)
-        return unless document&.footers && !document.footers.empty?
+      # Content types for raw-carried parts. Source Overrides survive
+      # reconciliation untouched (non-standard entries are preserved);
+      # a part whose content type came from a Default entry needs an
+      # Override once the reconciler rebuilds the standard Defaults.
+      def inject_raw_part_content_types(content_types)
+        return if raw_parts.empty?
 
-        idx = 0
-        document.footers.each_value do |footer_obj|
-          idx += 1
-          content["word/footer#{idx}.xml"] =
-            serialize_part(footer_obj)
-        end
-      end
+        raw_parts.each_value do |part|
+          next unless part.path && part.content_type
 
-      def serialize_header_footer_parts(content)
-        return unless document&.header_footer_parts && !document.header_footer_parts.empty?
+          ext = File.extname(part.path)[1..]
+          next if ext && content_types.defaults.any? do |d|
+            d.extension == ext
+          end
+
+          part_name = "/#{part.path}"
+          next if content_types.overrides.any? { |o| o.part_name == part_name }
 
-        document.header_footer_parts.each do |part|
-          content["word/#{part[:target]}"] =
-            serialize_part(part[:content])
+          content_types.overrides << Uniword::ContentTypes::Override.new(
+            part_name: part_name, content_type: part.content_type,
+          )
         end
       end
 
-      def serialize_embeddings(content)
-        return unless embeddings && !embeddings.empty?
+      # Emit raw-carried parts byte-for-byte. Model emission always
+      # wins: raw claiming already excludes registry paths, and the
+      # key guard makes double emission impossible by construction.
+      def serialize_raw_parts(content)
+        return if raw_parts.empty?
 
-        embeddings.each do |target, data|
-          content["word/#{target}"] = data
+        raw_parts.each do |path, part|
+          content[path] = part.content unless content.key?(path)
         end
       end
     end

data/lib/uniword/docx/part.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Docx
+    # Value object for one package-held part (chart, embedding,
+    # header, footer, ...).
+    #
+    # A Part couples the part's content (a lutaml-model object or a
+    # raw String) with the packaging metadata the OPC layer needs to
+    # emit it: relationship target, relationship id, content type and
+    # relationship type. Defaults for the metadata come from the
+    # part's Ooxml::PartDefinition (the single source of truth);
+    # loaded documents may carry verbatim overrides (e.g. strict-OOXML
+    # relationship URIs).
+    #
+    # Replaces the raw Hash entries previously stored in
+    # +chart_parts+, +embeddings+ and +header_footer_parts+. Hash-style
+    # read access (+part[:target]+) is kept for backward compatibility.
+    #
+    # @example
+    #   part = Part.new(
+    #     definition: Ooxml::PartRegistry.find_by_key(:ole_object),
+    #     target: "embeddings/file.xlsx",
+    #     content: binary_data,
+    #   )
+    #   part.path         # => "word/embeddings/file.xlsx"
+    #   part.content_type # => definition's content type
+    class Part
+      # @return [Ooxml::PartDefinition, nil] registry definition for
+      #   this part kind
+      attr_reader :definition
+
+      # @return [String, nil] relationship id (nil until wired)
+      attr_accessor :r_id
+
+      # @return [String, nil] relationship target relative to word/
+      attr_accessor :target
+
+      # @return [Object] part content (model object or raw String)
+      attr_accessor :content
+
+      # @param definition [Ooxml::PartDefinition, nil] registry entry
+      # @param r_id [String, nil] relationship id
+      # @param target [String, nil] relationship target (relative to
+      #   the owning part, e.g. "charts/chart1.xml")
+      # @param content [Object, nil] part content
+      # @param rel_type [String, nil] explicit relationship type
+      #   override (verbatim value from a loaded package)
+      # @param content_type [String, nil] explicit content type
+      #   override (verbatim value from a loaded package)
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(definition: nil, r_id: nil, target: nil, content: nil,
+                     rel_type: nil, content_type: nil)
+        @definition = definition
+        @r_id = r_id
+        @target = target
+        @content = content
+        @rel_type = rel_type
+        @content_type = content_type
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      # Wrap a legacy raw-hash entry ({ content:/xml:, target: }) into
+      # a Part. Subclasses override for family-specific keys (e.g.
+      # ImagePart's { data:, content_type:, path: }). Used by
+      # PartCollection to normalize hash assignments.
+      #
+      # @param hash [Hash] legacy hash entry
+      # @return [Part]
+      def self.from_hash(hash)
+        new(target: hash[:target], content: hash[:content] || hash[:xml])
+      end
+
+      # @return [String, nil] relationship type URI
+      def rel_type
+        @rel_type || definition&.rel_type
+      end
+
+      # @return [String, nil] MIME content type
+      def content_type
+        @content_type || definition&.content_type
+      end
+
+      # Package-relative path of the emitted part. Document-scoped
+      # parts live under word/; their target is already relative to
+      # word/.
+      #
+      # @return [String, nil] e.g. "word/charts/chart1.xml"
+      def path
+        target && "word/#{target}"
+      end
+
+      # Package paths this part emits (one for plain parts; subclasses
+      # with sidecar parts override).
+      #
+      # @return [Array<String>] emitted package paths
+      def package_paths
+        [path].compact
+      end
+
+      # Verbatim overrides carried from a loaded package.
+      attr_writer :rel_type, :content_type
+
+      # Key → reader lambdas backing hash-style access (kept as data
+      # so the dispatch stays declarative).
+      HASH_LOOKUP = {
+        r_id: lambda(&:r_id),
+        target: lambda(&:target),
+        rel_type: lambda(&:rel_type),
+        content_type: lambda(&:content_type),
+        content: lambda(&:content),
+        path: lambda(&:path),
+      }.freeze
+
+      # Hash-style read compatibility for former hash entries.
+      #
+      # @param key [Symbol, String] one of :r_id, :target, :rel_type,
+      #   :content_type, :content, :path
+      # @return [Object, nil]
+      def [](key)
+        HASH_LOOKUP[key.to_sym]&.call(self)
+      end
+    end
+  end
+end