uniword 1.0.10 → 1.2.4

data/lib/uniword/docx/id_allocator.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require "digest"
+
+module Uniword
+  module Docx
+    # Single owner of all ID assignment in a DOCX package.
+    #
+    # Every builder, the adapter, and the reconciler call into this class
+    # for rId, footnote, endnote, bookmark, comment, and paragraph ID
+    # allocation. No other code generates IDs.
+    #
+    # Two usage modes:
+    #   Creating from scratch — allocator starts empty, all IDs are fresh.
+    #   Editing a template   — call seed_from_* methods BEFORE any builder
+    #                           runs, so new IDs don't collide with existing ones.
+    #
+    # This is the "populate-first" principle: when loading a template DOCX,
+    # parse and seed ALL existing IDs from the template before modification.
+    class IdAllocator
+      REL_TYPE_BASE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships"
+
+      IMAGE_REL_TYPE = "#{REL_TYPE_BASE}/image"
+      HEADER_REL_TYPE = "#{REL_TYPE_BASE}/header"
+      FOOTER_REL_TYPE = "#{REL_TYPE_BASE}/footer"
+      HYPERLINK_REL_TYPE = "#{REL_TYPE_BASE}/hyperlink"
+      CHART_REL_TYPE = "#{REL_TYPE_BASE}/chart"
+      FOOTNOTES_REL_TYPE = "#{REL_TYPE_BASE}/footnotes"
+      ENDNOTES_REL_TYPE = "#{REL_TYPE_BASE}/endnotes"
+      THEME_REL_TYPE = "#{REL_TYPE_BASE}/theme"
+      NUMBERING_REL_TYPE = "#{REL_TYPE_BASE}/numbering"
+
+      def initialize
+        @rid_counter = 0
+        @rid_entries = {}  # [target, type] -> { id, type, target, target_mode }
+        @footnote_counter = 1
+        @endnote_counter = 1
+        @bookmark_counter = 0
+        @comment_counter = 0
+        @para_counter = 0
+        @rsid_counter = 0
+      end
+
+      # Allocate a relationship ID for a target+type pair.
+      # Returns existing rId if this target+type was already registered.
+      def alloc_rid(target:, type:, target_mode: nil)
+        key = [target, type.to_s]
+        @rid_entries[key] ||= begin
+          @rid_counter += 1
+          { id: "rId#{@rid_counter}", type: type.to_s,
+            target: target, target_mode: target_mode }
+        end
+        @rid_entries[key][:id]
+      end
+
+      def alloc_footnote_id
+        id = @footnote_counter
+        @footnote_counter += 1
+        id
+      end
+
+      def alloc_endnote_id
+        id = @endnote_counter
+        @endnote_counter += 1
+        id
+      end
+
+      def alloc_bookmark_id
+        @bookmark_counter += 1
+        @bookmark_counter.to_s
+      end
+
+      def alloc_comment_id
+        @comment_counter += 1
+        @comment_counter.to_s
+      end
+
+      def alloc_para_id
+        @para_counter += 1
+        Digest::SHA256.hexdigest("para:#{@para_counter}").upcase[0, 12]
+      end
+
+      def alloc_rsid
+        @rsid_counter += 1
+        Digest::SHA256.hexdigest("rsid:#{@rsid_counter}").upcase[0, 12]
+      end
+
+      # Seed from a relationships collection — preserves existing rIds.
+      def seed_from_rels(relationships)
+        return unless relationships
+
+        relationships.each do |r|
+          key = [r.target, r.type.to_s]
+          @rid_entries[key] = {
+            id: r.id,
+            type: r.type.to_s,
+            target: r.target,
+            target_mode: r.target_mode,
+          }
+          num = r.id[/\ArId(\d+)\z/, 1]&.to_i || 0
+          @rid_counter = [@rid_counter, num].max
+        end
+      end
+
+      # Seed footnote/endnote counters from existing note entries.
+      def seed_from_notes(footnote_entries, endnote_entries)
+        footnote_entries&.each do |e|
+          id = e.id.to_i
+          @footnote_counter = [@footnote_counter, id + 1].max if id > 0
+        end
+        endnote_entries&.each do |e|
+          id = e.id.to_i
+          @endnote_counter = [@endnote_counter, id + 1].max if id > 0
+        end
+      end
+
+      # Produce the final ordered list of all allocated relationships.
+      def all_rels
+        @rid_entries.values.sort_by { |r| r[:id][/\d+/]&.to_i || 0 }
+      end
+
+      # Check if a relationship has been registered for a target+type.
+      def rid_for(target:, type:)
+        key = [target, type.to_s]
+        @rid_entries[key]&.fetch(:id, nil)
+      end
+
+      # Build an allocator seeded from every source on a package in one call.
+      # Used by both Package#populate_allocator and DocumentBuilder.from_template
+      # so they cannot drift apart.
+      def self.populate_from_package(package)
+        alloc = new
+        alloc.seed_from_rels(package.document_rels&.relationships)
+        alloc.seed_from_rels(package.package_rels&.relationships)
+        alloc.seed_from_notes(
+          package.footnotes&.footnote_entries,
+          package.endnotes&.endnote_entries,
+        )
+        alloc
+      end
+    end
+  end
+end

data/lib/uniword/docx/package.rb

@@ -2,9 +2,6 @@
 
 require "securerandom"
 require "lutaml/model"
-require_relative "reconciler"
-require_relative "package_defaults"
-require_relative "package_serialization"
 
 module Uniword
   module Docx
@@ -89,6 +86,18 @@ module Uniword
       attr_accessor :chart_parts, :bibliography_sources, :profile
       attr_accessor :settings_rels, :embeddings
 
+      # Central ID allocator — owns all rId, footnote, bookmark, etc. assignment.
+      # Seeded from template rels on load; used by builders during construction.
+      attr_accessor :allocator
+
+      # Raw XML from template ZIP for unmodified parts.
+      # When present, these are used verbatim instead of re-serializing
+      # through lutaml-model (which drops unmapped elements).
+      attr_accessor :raw_xml_parts
+
+      # Paths that have been modified and should not use raw XML passthrough.
+      attr_accessor :modified_part_paths
+
       # Load DOCX package from file
       #
       # @param path [String] Path to .docx file
@@ -96,7 +105,9 @@ module Uniword
       def self.from_file(path)
         extractor = Infrastructure::ZipExtractor.new
         zip_content = extractor.extract(path)
-        from_zip_content(zip_content, path)
+        package = from_zip_content(zip_content, path)
+        package.populate_allocator
+        package
       end
 
       # Create package from extracted ZIP content
@@ -364,7 +375,14 @@ module Uniword
                          else "image/#{ext}"
                          end
 
-          r_id = "rIdImg#{package.document.image_parts.size + 1}"
+          r_id = if package.allocator
+                   package.allocator.alloc_rid(
+                     target: "media/#{filename}",
+                     type: IdAllocator::IMAGE_REL_TYPE,
+                   )
+                 else
+                   "rId#{package.document.image_parts.size + 1}"
+                 end
 
           binary_data = if zip_path
                           read_binary_from_zip(zip_path, media_path)
@@ -406,6 +424,12 @@ module Uniword
         package.to_file(path)
       end
 
+      # Populate the allocator from all existing template data.
+      # Must be called BEFORE any builder runs (populate-first principle).
+      def populate_allocator
+        @allocator = IdAllocator.populate_from_package(self)
+      end
+
       # Extract media files from word/theme/media/ directory
       def self.extract_theme_media(zip_content)
         media = {}
@@ -443,14 +467,26 @@ module Uniword
         self.font_table ||= Uniword::Wordprocessingml::FontTable.new
         self.web_settings ||= Uniword::Wordprocessingml::WebSettings.new
 
-        Reconciler.new(self, profile: profile || Profile.defaults).reconcile
+        Reconciler.new(self,
+                       profile: profile || Profile.defaults,
+                       allocator: allocator).reconcile
 
         inject_part_relationships(content, content_types, package_rels, document_rels)
         serialize_package_parts(content, content_types, package_rels, document_rels)
 
+        # OOXML requires [Content_Types].xml as the first ZIP entry.
+        reorder_content_hash(content)
         content
       end
 
+      # Ensure [Content_Types].xml is first, _rels/.rels is second.
+      def reorder_content_hash(content)
+        priority = {}
+        priority["[Content_Types].xml"] = content.delete("[Content_Types].xml") if content.key?("[Content_Types].xml")
+        priority["_rels/.rels"] = content.delete("_rels/.rels") if content.key?("_rels/.rels")
+        content.replace(priority.merge(content))
+      end
+
       # Delegate common DocumentRoot methods for API compatibility
 
       def paragraphs

data/lib/uniword/docx/package_defaults.rb

@@ -9,29 +9,8 @@ module Uniword
     #
     # @api private
     module PackageDefaults
-      # Mapping from DocumentRoot attributes to Package attributes.
-      # Only entries where names differ need explicit mapping.
-      DOCUMENT_TO_PACKAGE_MAPPINGS = {
-        styles_configuration: :styles,
-        settings: :settings,
-        font_table: :font_table,
-        web_settings: :web_settings,
-        theme: :theme,
-        core_properties: :core_properties,
-        app_properties: :app_properties,
-        custom_properties: :custom_properties,
-        document_rels: :document_rels,
-        theme_rels: :theme_rels,
-        package_rels: :package_rels,
-        content_types: :content_types,
-        footnotes: :footnotes,
-        endnotes: :endnotes,
-      }.freeze
-
       def self.included(base)
         base.extend(ClassMethods)
-        base.const_set(:DOCUMENT_TO_PACKAGE_MAPPINGS,
-                       DOCUMENT_TO_PACKAGE_MAPPINGS)
       end
 
       # Class methods for package construction
@@ -40,16 +19,28 @@ module Uniword
         def copy_document_parts_to_package(document, package)
           return unless document.is_a?(Uniword::Wordprocessingml::DocumentRoot)
 
-          DOCUMENT_TO_PACKAGE_MAPPINGS.each do |doc_attr, pkg_attr|
-            value = document.public_send(doc_attr)
-            package.public_send(:"#{pkg_attr}=", value) if value
-          end
+          package.styles = document.styles_configuration if document.styles_configuration
+          package.settings = document.settings if document.settings
+          package.font_table = document.font_table if document.font_table
+          package.web_settings = document.web_settings if document.web_settings
+          package.theme = document.theme if document.theme
+          package.core_properties = document.core_properties if document.core_properties
+          package.app_properties = document.app_properties if document.app_properties
+          package.custom_properties = document.custom_properties if document.custom_properties
+          package.document_rels = document.document_rels if document.document_rels
+          package.theme_rels = document.theme_rels if document.theme_rels
+          package.package_rels = document.package_rels if document.package_rels
+          package.content_types = document.content_types if document.content_types
+          package.footnotes = document.footnotes if document.footnotes
+          package.endnotes = document.endnotes if document.endnotes
+          package.allocator = document.allocator if document.allocator
 
           package.numbering = document.numbering_configuration if document.numbering_configuration_loaded?
 
           package.chart_parts = document.chart_parts if document.chart_parts
           package.custom_xml_items = document.custom_xml_items if document.custom_xml_items
           package.bibliography_sources = document.bibliography_sources if document.bibliography_sources
+          package.embeddings = document.embeddings if document.embeddings
         end
 
         # Create minimal content types for a valid DOCX

data/lib/uniword/docx/package_serialization.rb

@@ -12,6 +12,30 @@ module Uniword
     #
     # @api private
     module PackageSerialization
+      DOCX_XML_OPTIONS = {
+        encoding: "UTF-8",
+        indent: 0,
+        line_ending: "\r\n",
+      }.freeze
+
+      DOCX_PART_OPTIONS = {
+        **DOCX_XML_OPTIONS,
+        prefix: true,
+        standalone: true,
+      }.freeze
+
+      DOCX_INFRA_OPTIONS = {
+        **DOCX_XML_OPTIONS,
+        declaration: true,
+        standalone: true,
+      }.freeze
+
+      DOCX_PROPS_OPTIONS = {
+        **DOCX_XML_OPTIONS,
+        prefix: false,
+        standalone: true,
+      }.freeze
+
       # Inject content types and relationships for all package parts
       def inject_part_relationships(content, content_types, package_rels,
 document_rels)
@@ -45,15 +69,11 @@ document_rels)
         end
         if app_properties
           content["docProps/app.xml"] =
-            app_properties.to_xml(encoding: "UTF-8",
-                                  prefix: false,
-                                  standalone: true)
+            app_properties.to_xml(DOCX_PROPS_OPTIONS.dup)
         end
         if custom_properties
           content["docProps/custom.xml"] =
-            custom_properties.to_xml(encoding: "UTF-8",
-                                     prefix: false,
-                                     standalone: true)
+            custom_properties.to_xml(DOCX_PROPS_OPTIONS.dup)
         end
 
         # Custom XML data items
@@ -141,18 +161,47 @@ document_rels)
         serialize_embeddings(content)
       end
 
-      # Serialize an OOXML document part with standard encoding
+      # Serialize an OOXML document part with standard encoding, single-line output
       def serialize_part(model)
-        model.to_xml(encoding: "UTF-8", prefix: true, standalone: true)
+        model.to_xml(DOCX_PART_OPTIONS.dup)
       end
 
-      # Serialize package infrastructure (rels, content types) with declaration
+      # Serialize package infrastructure (rels, content types) with declaration, single-line output
       def serialize_infrastructure(model)
-        model.to_xml(encoding: "UTF-8", declaration: true, standalone: true)
+        model.to_xml(DOCX_INFRA_OPTIONS.dup)
       end
 
       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 }
+
+        rels.relationships << Ooxml::Relationships::Relationship.new(
+          id: next_rid(rels), type: rel_type, target: target,
+        )
+      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)
         return unless document&.image_parts && !document.image_parts.empty?
 
@@ -165,8 +214,15 @@ document_rels)
           )
         end
 
-        document.image_parts.each do |r_id, image_data|
+        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",
@@ -200,24 +256,11 @@ document_rels)
       def inject_bibliography(content_types, document_rels)
         return unless document&.bibliography_sources
 
-        unless content_types.overrides.any? do |o|
-          o.part_name == "/word/sources.xml"
-        end
-          content_types.overrides << Uniword::ContentTypes::Override.new(
-            part_name: "/word/sources.xml",
-            content_type: "application/vnd.openxmlformats-officedocument.bibliography+xml",
-          )
-        end
-
-        return if document_rels.relationships.any? do |r|
-          r.target == "sources.xml"
-        end
-
-        document_rels.relationships << Ooxml::Relationships::Relationship.new(
-          id: "rIdSrc#{SecureRandom.hex(4)}",
-          type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/bibliography",
-          target: "sources.xml",
-        )
+        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")
       end
 
       def inject_custom_properties(content_types, package_rels)
@@ -232,15 +275,15 @@ document_rels)
           )
         end
 
-        unless package_rels.relationships.any? do |r|
+        return if package_rels.relationships.any? do |r|
           r.type.to_s.include?("officeDocument/2006/relationships/custom-properties")
         end
-          package_rels.relationships << Ooxml::Relationships::Relationship.new(
-            id: "rIdCustProps",
-            type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/custom-properties",
-            target: "docProps/custom.xml",
-          )
-        end
+
+        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",
+        )
       end
 
       def inject_custom_xml(content_types)
@@ -265,17 +308,23 @@ document_rels)
         counter = 0
         document.headers.each_key do |type|
           counter += 1
-          r_id = "rIdHeader#{counter}"
+          target = "header#{counter}.xml"
 
-          content_types.overrides << Uniword::ContentTypes::Override.new(
-            part_name: "/word/header#{counter}.xml",
-            content_type: "application/vnd.openxmlformats-officedocument.wordprocessingml.header+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: "header#{counter}.xml",
+            target: target,
           )
 
           wire_header_reference(type, r_id)
@@ -288,17 +337,23 @@ document_rels)
         counter = 0
         document.footers.each_key do |type|
           counter += 1
-          r_id = "rIdFooter#{counter}"
+          target = "footer#{counter}.xml"
 
-          content_types.overrides << Uniword::ContentTypes::Override.new(
-            part_name: "/word/footer#{counter}.xml",
-            content_type: "application/vnd.openxmlformats-officedocument.wordprocessingml.footer+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: "footer#{counter}.xml",
+            target: target,
           )
 
           wire_footer_reference(type, r_id)
@@ -317,104 +372,53 @@ document_rels)
             )
           end
 
-          unless document_rels.relationships.any? { |r| r.id == part[:r_id] }
-            document_rels.relationships << Ooxml::Relationships::Relationship.new(
-              id: part[:r_id],
-              type: part[:rel_type],
-              target: part[:target],
-            )
-          end
+          next if allocator
+          next if document_rels.relationships.any? { |r| r.id == part[:r_id] }
+
+          document_rels.relationships << Ooxml::Relationships::Relationship.new(
+            id: part[:r_id],
+            type: part[:rel_type],
+            target: part[:target],
+          )
         end
       end
 
       def inject_notes(content_types, document_rels)
         if footnotes
-          unless content_types.overrides.any? do |o|
-            o.part_name == "/word/footnotes.xml"
-          end
-            content_types.overrides << Uniword::ContentTypes::Override.new(
-              part_name: "/word/footnotes.xml",
-              content_type: "application/vnd.openxmlformats-officedocument.wordprocessingml.footnotes+xml",
-            )
-          end
-
-          unless document_rels.relationships.any? do |r|
-            r.target == "footnotes.xml"
-          end
-            document_rels.relationships << Ooxml::Relationships::Relationship.new(
-              id: "rIdFootnotes",
-              type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footnotes",
-              target: "footnotes.xml",
-            )
-          end
+          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")
         end
 
         return unless endnotes
 
-        unless content_types.overrides.any? do |o|
-          o.part_name == "/word/endnotes.xml"
-        end
-          content_types.overrides << Uniword::ContentTypes::Override.new(
-            part_name: "/word/endnotes.xml",
-            content_type: "application/vnd.openxmlformats-officedocument.wordprocessingml.endnotes+xml",
-          )
-        end
-
-        return if document_rels.relationships.any? do |r|
-          r.target == "endnotes.xml"
-        end
-
-        document_rels.relationships << Ooxml::Relationships::Relationship.new(
-          id: "rIdEndnotes",
-          type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/endnotes",
-          target: "endnotes.xml",
-        )
+        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")
       end
 
       def inject_theme(content_types, document_rels)
         return unless theme
 
-        unless content_types.overrides.any? do |o|
-          o.part_name == "/word/theme/theme1.xml"
-        end
-          content_types.overrides << Uniword::ContentTypes::Override.new(
-            part_name: "/word/theme/theme1.xml",
-            content_type: "application/vnd.openxmlformats-officedocument.theme+xml",
-          )
-        end
-
-        return if document_rels.relationships.any? do |r|
-          r.target == "theme/theme1.xml"
-        end
-
-        document_rels.relationships << Ooxml::Relationships::Relationship.new(
-          id: "rIdTheme",
-          type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme",
-          target: "theme/theme1.xml",
-        )
+        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")
       end
 
       def inject_numbering(content_types, document_rels)
         return unless numbering
 
-        unless content_types.overrides.any? do |o|
-          o.part_name == "/word/numbering.xml"
-        end
-          content_types.overrides << Uniword::ContentTypes::Override.new(
-            part_name: "/word/numbering.xml",
-            content_type: "application/vnd.openxmlformats-officedocument.wordprocessingml.numbering+xml",
-          )
-        end
-
-        return if document_rels.relationships.any? do |r|
-          r.target == "numbering.xml"
-        end
-
-        document_rels.relationships << Ooxml::Relationships::Relationship.new(
-          id: "rIdNumbering",
-          type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/numbering",
-          target: "numbering.xml",
-        )
+        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")
       end
 
       def inject_embeddings(content_types, document_rels)