uniword 1.3.0 → 1.4.1

data/lib/uniword/docx/package.rb

@@ -94,7 +94,7 @@ module Uniword
       attribute :comments, Uniword::CommentsPart
 
       # Non-serialized attributes (DOCX packaging helpers)
-      attr_accessor :chart_parts, :bibliography_sources, :profile
+      attr_accessor :profile
       attr_accessor :settings_rels, :footnotes_rels, :endnotes_rels
 
       # OLE/embedded object binaries (word/embeddings/*), keyed by target.
@@ -109,6 +109,22 @@ module Uniword
         embeddings.replace_all(value)
       end
 
+      # Raw passthrough parts no registry definition models, keyed by
+      # package path ("docProps/meta.xml", "word/glossary/document.xml",
+      # ...). Carried byte-for-byte from load to save — see
+      # PartLoader::RawPartLoader for claiming and
+      # PackageSerialization#serialize_raw_parts for emission.
+      #
+      # @return [PartCollection] package path => RawPart
+      def raw_parts
+        @raw_parts ||= PartCollection.new(:path, RawPart)
+      end
+
+      # Bulk-assign raw parts (Hash of path => RawPart/hash; nil clears).
+      def raw_parts=(value)
+        raw_parts.replace_all(value)
+      end
+
       # Central ID allocator — owns all rId, footnote, bookmark, etc. assignment.
       # Seeded from template rels on load; used by builders during construction.
       attr_accessor :allocator
@@ -144,374 +160,19 @@ module Uniword
 
       # Create package from extracted ZIP content
       #
+      # Parts load by iterating Ooxml::PartRegistry.loadable and
+      # dispatching each definition to its Docx::PartLoader strategy —
+      # see PartLoader for the load order and strategy registry.
+      #
       # @param zip_content [Hash] Extracted ZIP files
       # @param zip_path [String, nil] Original ZIP path for binary re-extraction
       # @return [Package] Package object
       def self.from_zip_content(zip_content, zip_path = nil)
         package = new
-
-        # Parse Content Types
-        if zip_content["[Content_Types].xml"]
-          package.content_types = Uniword::ContentTypes::Types.from_xml(
-            zip_content["[Content_Types].xml"]
-          )
-        end
-
-        # Parse Package Relationships
-        if zip_content["_rels/.rels"]
-          package.package_rels = Ooxml::Relationships::PackageRelationships.from_xml(
-            zip_content["_rels/.rels"]
-          )
-        end
-
-        # Find the main document path from officeDocument relationship
-        main_doc_path = find_main_document_path(package.package_rels)
-        main_doc_rels_path = find_document_rels_path(main_doc_path)
-
-        # Parse Document Properties
-        if zip_content["docProps/core.xml"]
-          package.core_properties = Ooxml::CoreProperties.from_xml(
-            zip_content["docProps/core.xml"]
-          )
-        end
-
-        if zip_content["docProps/app.xml"]
-          package.app_properties = Ooxml::AppProperties.from_xml(
-            zip_content["docProps/app.xml"]
-          )
-        end
-
-        # Parse Custom Properties
-        if zip_content["docProps/custom.xml"]
-          package.custom_properties = Ooxml::CustomProperties.from_xml(
-            zip_content["docProps/custom.xml"]
-          )
-        end
-
-        # Parse Custom XML Data items (customXml/item*.xml)
-        custom_xml_files = zip_content.keys.grep(%r{^customXml/item(\d+)\.xml$})
-        if custom_xml_files.any?
-          package.custom_xml_items = []
-          custom_xml_files.sort_by { |f| f[/item(\d+)/, 1].to_i }.each do |item_path|
-            index = item_path[/item(\d+)/, 1].to_i
-            props_path = "customXml/itemProps#{index}.xml"
-            rels_path = "customXml/_rels/item#{index}.xml.rels"
-
-            package.custom_xml_items << CustomXmlItem.new(
-              index: index,
-              xml_content: zip_content[item_path],
-              props_xml: zip_content[props_path],
-              rels_xml: zip_content[rels_path],
-            )
-          end
-        end
-
-        # Parse Document Parts - use dynamic path from package relationships
-        if main_doc_path && zip_content[main_doc_path]
-          package.document = Uniword::Wordprocessingml::DocumentRoot.from_xml(
-            zip_content[main_doc_path]
-          )
-        elsif zip_content["word/document.xml"]
-          package.document = Uniword::Wordprocessingml::DocumentRoot.from_xml(
-            zip_content["word/document.xml"]
-          )
-        end
-
-        if zip_content["word/styles.xml"]
-          package.styles = Uniword::Wordprocessingml::StylesConfiguration.from_xml(
-            zip_content["word/styles.xml"]
-          )
-        end
-
-        if zip_content["word/numbering.xml"]
-          package.numbering = Uniword::Wordprocessingml::NumberingConfiguration.from_xml(
-            zip_content["word/numbering.xml"]
-          )
-        end
-
-        if zip_content["word/settings.xml"]
-          package.settings = Uniword::Wordprocessingml::Settings.from_xml(
-            zip_content["word/settings.xml"]
-          )
-        end
-
-        if zip_content["word/_rels/settings.xml.rels"]
-          package.settings_rels =
-            Ooxml::Relationships::PackageRelationships.from_xml(
-              zip_content["word/_rels/settings.xml.rels"]
-            )
-        end
-
-        if zip_content["word/fontTable.xml"]
-          package.font_table = Uniword::Wordprocessingml::FontTable.from_xml(
-            zip_content["word/fontTable.xml"]
-          )
-        end
-
-        if zip_content["word/webSettings.xml"]
-          package.web_settings = Uniword::Wordprocessingml::WebSettings.from_xml(
-            zip_content["word/webSettings.xml"]
-          )
-        end
-
-        # Parse document relationships - use dynamic path based on main document
-        if main_doc_rels_path && zip_content[main_doc_rels_path]
-          package.document_rels = Ooxml::Relationships::PackageRelationships.from_xml(
-            zip_content[main_doc_rels_path]
-          )
-        elsif zip_content["word/_rels/document.xml.rels"]
-          package.document_rels = Ooxml::Relationships::PackageRelationships.from_xml(
-            zip_content["word/_rels/document.xml.rels"]
-          )
-        end
-
-        # Parse Theme
-        if zip_content["word/theme/theme1.xml"]
-          package.theme = Drawingml::Theme.from_xml(
-            zip_content["word/theme/theme1.xml"]
-          )
-
-          theme_media = extract_theme_media(zip_content)
-          package.theme.media_files = theme_media if theme_media.any?
-        end
-
-        if zip_content["word/theme/_rels/theme1.xml.rels"]
-          package.theme_rels = Ooxml::Relationships::PackageRelationships.from_xml(
-            zip_content["word/theme/_rels/theme1.xml.rels"]
-          )
-        end
-
-        # Parse Footnotes
-        if zip_content["word/footnotes.xml"]
-          package.footnotes = Uniword::Wordprocessingml::Footnotes.from_xml(
-            zip_content["word/footnotes.xml"]
-          )
-        end
-
-        # Parse Endnotes
-        if zip_content["word/endnotes.xml"]
-          package.endnotes = Uniword::Wordprocessingml::Endnotes.from_xml(
-            zip_content["word/endnotes.xml"]
-          )
-        end
-
-        # Parse Comments
-        if zip_content["word/comments.xml"]
-          package.comments = Uniword::CommentsPart.from_xml(
-            zip_content["word/comments.xml"]
-          )
-        end
-
-        # Parse note part relationships (r:id refs inside notes, e.g.
-        # hyperlinks in footnotes) so they survive the round-trip.
-        if zip_content["word/_rels/footnotes.xml.rels"]
-          package.footnotes_rels =
-            Ooxml::Relationships::PackageRelationships.from_xml(
-              zip_content["word/_rels/footnotes.xml.rels"]
-            )
-        end
-
-        if zip_content["word/_rels/endnotes.xml.rels"]
-          package.endnotes_rels =
-            Ooxml::Relationships::PackageRelationships.from_xml(
-              zip_content["word/_rels/endnotes.xml.rels"]
-            )
-        end
-
-        # Parse Header and Footer parts
-        extract_header_footer_parts(zip_content, package)
-
-        # Parse Chart parts
-        chart_files = zip_content.keys.grep(%r{^word/charts/chart\d+\.xml$})
-        if chart_files.any? && package.document_rels
-          chart_files.each do |chart_path|
-            chart_target = chart_path.sub("word/", "")
-            rel = package.document_rels.relationships.find do |r|
-              r.target == chart_target &&
-                r.type.to_s.include?("officeDocument/2006/relationships/chart")
-            end
-            next unless rel
-
-            package.document.chart_parts[rel.id] = {
-              xml: zip_content[chart_path],
-              target: chart_target
-            }
-          end
-        end
-
-        # Extract image parts from word/media/ directory
-        extract_image_parts(zip_content, package, zip_path)
-
-        # Extract OLE/embedded object binaries from word/embeddings/
-        embedding_files = zip_content.keys.grep(%r{^word/embeddings/.+$})
-        if embedding_files.any?
-          package.embeddings = {}
-          embedding_files.each do |emb_path|
-            target = emb_path.sub("word/", "")
-            package.embeddings[target] = zip_content[emb_path]
-          end
-        end
-
+        PartLoader.load(zip_content, package, zip_path: zip_path)
         package
       end
 
-      def self.extract_header_footer_parts(zip_content, package)
-        return unless package.document && package.document_rels
-
-        header_files = zip_content.keys.grep(%r{^word/header\d+\.xml$})
-        footer_files = zip_content.keys.grep(%r{^word/footer\d+\.xml$})
-
-        return if header_files.empty? && footer_files.empty?
-
-        store = package.document.header_footer_parts
-        ref_types = header_footer_reference_types(package.document)
-
-        header_files.sort.each do |path|
-          target = path.sub("word/", "")
-          rel = package.document_rels.relationships.find do |r|
-            r.target == target &&
-              r.type.to_s.include?("officeDocument/2006/relationships/header")
-          end
-          next unless rel
-
-          store << HeaderFooterPart.new(
-            kind: :header,
-            r_id: rel.id,
-            target: target,
-            rel_type: rel.type,
-            type: ref_types[rel.id],
-            content: Uniword::Wordprocessingml::Header.from_xml(zip_content[path]),
-            loaded: true,
-          )
-        end
-
-        footer_files.sort.each do |path|
-          target = path.sub("word/", "")
-          rel = package.document_rels.relationships.find do |r|
-            r.target == target &&
-              r.type.to_s.include?("officeDocument/2006/relationships/footer")
-          end
-          next unless rel
-
-          store << HeaderFooterPart.new(
-            kind: :footer,
-            r_id: rel.id,
-            target: target,
-            rel_type: rel.type,
-            type: ref_types[rel.id],
-            content: Uniword::Wordprocessingml::Footer.from_xml(zip_content[path]),
-            loaded: true,
-          )
-        end
-      end
-
-      # Map relationship id => sectPr reference type
-      # ("default"/"first"/"even") from every section properties
-      # element (body-level and paragraph-level).
-      def self.header_footer_reference_types(document)
-        types = {}
-        section_properties_of(document).each do |sect_pr|
-          (sect_pr.header_references || []).each do |ref|
-            types[ref.r_id] = ref.type if ref.r_id
-          end
-          (sect_pr.footer_references || []).each do |ref|
-            types[ref.r_id] = ref.type if ref.r_id
-          end
-        end
-        types
-      end
-
-      def self.section_properties_of(document)
-        body = document.body
-        return [] unless body
-
-        sect_prs = []
-        sect_prs << body.section_properties if body.section_properties
-        (body.paragraphs || []).each do |para|
-          sect_pr = para.properties&.section_properties
-          sect_prs << sect_pr if sect_pr
-        end
-        sect_prs
-      end
-
-      # Extract image files from word/media/ directory in DOCX
-      #
-      # @param zip_content [Hash] Extracted ZIP content (may have corrupted binary)
-      # @param package [Package] Package to populate
-      # @param zip_path [String, nil] Original ZIP path for binary re-extraction
-      def self.extract_image_parts(zip_content, package, zip_path = nil)
-        return unless package.document
-
-        media_files = zip_content.keys.grep(%r{^word/media/.+$})
-        return if media_files.empty?
-
-        package.document.image_parts ||= {}
-
-        media_files.each do |media_path|
-          filename = File.basename(media_path)
-          ext = File.extname(filename).delete(".").downcase
-          content_type = case ext
-                         when "jpg", "jpeg" then "image/jpeg"
-                         when "png" then "image/png"
-                         when "gif" then "image/gif"
-                         when "bmp" then "image/bmp"
-                         when "tiff", "tif" then "image/tiff"
-                         when "svg" then "image/svg+xml"
-                         else "image/#{ext}"
-                         end
-
-          # Key the part by the rId the loaded document rels assign to
-          # this target, so downstream consumers (MHTML rendering, image
-          # manager) resolve r:embed references correctly. Media with no
-          # document-level rel (e.g. theme-only images) gets a synthetic
-          # key; it never becomes a relationship.
-          r_id = loaded_image_rid(package, filename) ||
-            next_synthetic_image_key(package)
-
-          binary_data = if zip_path
-                          read_binary_from_zip(zip_path, media_path)
-                        else
-                          zip_content[media_path]
-                        end
-
-          package.document.image_parts[r_id] = {
-            data: binary_data,
-            target: "media/#{filename}",
-            content_type: content_type
-          }
-        end
-      end
-
-      # The rId a loaded document relationship assigns to
-      # "media/<filename>", or nil when no image rel targets it.
-      def self.loaded_image_rid(package, filename)
-        image_type = Ooxml::PartRegistry.find_by_key(:image).rel_type
-        rel = package.document_rels&.relationships&.find do |r|
-          r.target == "media/#{filename}" && r.type.to_s == image_type
-        end
-        rel&.id
-      end
-
-      # Synthetic image-part key that cannot collide with a loaded
-      # relationship id or an already-keyed image part.
-      def self.next_synthetic_image_key(package)
-        taken = package.document_rels&.relationships&.map(&:id) || []
-        n = package.document.image_parts.size + 1
-        n += 1 while taken.include?("rId#{n}")
-        "rId#{n}"
-      end
-
-      # Read binary data directly from ZIP file without UTF-8 encoding
-      def self.read_binary_from_zip(zip_path, entry_path)
-        require "zip"
-        Zip::File.open(zip_path) do |zip_file|
-          entry = zip_file.find_entry(entry_path)
-          return nil unless entry
-
-          entry.get_input_stream.read
-        end
-      end
-
       # Save document to file (class method for DocumentWriter compatibility)
       #
       # @param document [Wordprocessingml::DocumentRoot] Document to save
@@ -554,24 +215,6 @@ module Uniword
         allocator
       end
 
-      # Extract media files from word/theme/media/ directory
-      def self.extract_theme_media(zip_content)
-        media = {}
-
-        zip_content.each_key do |file_path|
-          next unless file_path =~ %r{^word/theme/media/(.+)$}
-
-          filename = Regexp.last_match(1)
-          media[filename] = Uniword::Themes::MediaFile.new(
-            filename: filename,
-            content: zip_content[file_path],
-            source_path: file_path
-          )
-        end
-
-        media
-      end
-
       # Save package to file
       #
       # @param path [String] Output file path
@@ -673,29 +316,6 @@ module Uniword
         document&.styles_configuration
       end
 
-      # Find the main document path from package relationships
-      def self.find_main_document_path(package_rels)
-        return nil unless package_rels&.relationships
-
-        rel = package_rels.relationships.find do |r|
-          r.type.to_s.include?("officeDocument/2006/relationships/officeDocument")
-        end
-        return nil unless rel&.target
-
-        path = rel.target.dup
-        path.sub!(%r{^/}, "")
-        path
-      end
-
-      # Find the document relationships path from the main document path
-      def self.find_document_rels_path(doc_path)
-        return nil unless doc_path
-
-        dir = File.dirname(doc_path)
-        basename = File.basename(doc_path)
-        File.join(dir, "_rels", "#{basename}.rels")
-      end
-
       private
 
       # Log each applied fix via Uniword.logger when policy allows.

data/lib/uniword/docx/package_defaults.rb

@@ -31,43 +31,20 @@ module Uniword
           %i[styles settings web_settings font_table].freeze
 
         # Copy parts from document to package for round-trip preservation
+        #
+        # Registry-driven: every PartDefinition naming both a document
+        # and a package attribute is mirrored, honoring the
+        # definition's optional +to_package_guard+ predicate (e.g. the
+        # lazily-initialized numbering configuration) and
+        # +to_package_type+ value constraint (e.g. comments).
         def copy_document_parts_to_package(document, package)
           return unless document.is_a?(Uniword::Wordprocessingml::DocumentRoot)
 
-          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
-          if document.settings_rels
-            package.settings_rels = document.settings_rels
+          Ooxml::PartRegistry.copied_to_package.each do |definition|
+            copy_part_to_package(document, package, definition)
           end
-          if document.footnotes_rels
-            package.footnotes_rels = document.footnotes_rels
-          end
-          if document.endnotes_rels
-            package.endnotes_rels = document.endnotes_rels
-          end
-          package.content_types = document.content_types if document.content_types
-          package.footnotes = document.footnotes if document.footnotes
-          package.endnotes = document.endnotes if document.endnotes
-          if document.comments.is_a?(Uniword::CommentsPart)
-            package.comments = document.comments
-          end
-          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
+          package.allocator = document.allocator if document.allocator
         end
 
         # Create minimal content types for a valid DOCX
@@ -102,6 +79,33 @@ module Uniword
 
         private
 
+        # Copy one document part to the package when the definition's
+        # guard predicate and value type constraint allow it.
+        def copy_part_to_package(document, package, definition)
+          return unless copyable_to_package?(document, definition)
+
+          value = document.method(definition.document_attribute).call
+          return if value.nil?
+          return unless copyable_type?(definition, value)
+
+          package.method(:"#{definition.package_attribute}=").call(value)
+        end
+
+        # The guard predicate named by the definition (a method on the
+        # document, e.g. :numbering_configuration_loaded?) decides;
+        # without a guard the part copies.
+        def copyable_to_package?(document, definition)
+          guard = definition.to_package_guard
+          guard.nil? || document.method(guard).call
+        end
+
+        # When the definition constrains the value type (e.g.
+        # CommentsPart for comments), the value must satisfy it.
+        def copyable_type?(definition, value)
+          type = definition.to_package_type
+          type.nil? || value.is_a?(type)
+        end
+
         # Build a Relationships part with sequential rIds (rId1..rIdN)
         # for the given registry part keys, in the given order.
         def build_minimal_rels(part_keys)

data/lib/uniword/docx/package_serialization.rb

@@ -50,6 +50,7 @@ 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
@@ -155,6 +156,9 @@ document_rels)
 
         # 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.
@@ -198,17 +202,17 @@ 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]
+        document.image_parts.each_value do |part|
+          content["word/#{part.target}"] = part.data
         end
       end
 
@@ -225,8 +229,8 @@ document_rels)
           )
         end
 
-        document.chart_parts.each_value do |chart_data|
-          content["word/#{chart_data[:target]}"] = chart_data[:xml]
+        document.chart_parts.each_value do |part|
+          content["word/#{part.target}"] = part.xml
         end
       end
 
@@ -391,6 +395,41 @@ document_rels)
           content["word/#{target}"] = part.content
         end
       end
+
+      # 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?
+
+        raw_parts.each_value do |part|
+          next unless part.path && part.content_type
+
+          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 }
+
+          content_types.overrides << Uniword::ContentTypes::Override.new(
+            part_name: part_name, content_type: part.content_type,
+          )
+        end
+      end
+
+      # 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?
+
+        raw_parts.each do |path, part|
+          content[path] = part.content unless content.key?(path)
+        end
+      end
     end
   end
 end

data/lib/uniword/docx/part.rb

@@ -60,6 +60,17 @@ module Uniword
       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
@@ -79,6 +90,14 @@ module Uniword
         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