uniword 1.6.0 → 1.7.0

data/lib/uniword/ooxml/schema/element_serializer.rb

@@ -67,7 +67,7 @@ module Uniword
           schema_def = @schema.definition_for(element.class)
 
           # Build XML document
-          doc = Nokogiri::XML::Document.new
+          doc = Moxml.new.create_document
 
           # Create root element with proper namespace
           root = serialize_element_to_node(doc, element, schema_def, options)
@@ -105,21 +105,21 @@ module Uniword
           OoxmlSchema.load(schema_path)
         end
 
-        # Serialize element to Nokogiri node
+        # Serialize element to Moxml node
         #
-        # @param doc [Nokogiri::XML::Document] XML document
+        # @param doc [Moxml::Document] XML document
         # @param element [Element] Element to serialize
         # @param schema_def [ElementDefinition] Schema definition
         # @param options [Hash] Serialization options
-        # @return [Nokogiri::XML::Node] Created node
+        # @return [Moxml::Element] Created node
         def serialize_element_to_node(doc, element, schema_def, options)
           # Create element node with namespace
           prefix = schema_def.prefix
           local_name = schema_def.local_name
           namespace_uri = @schema.namespace[:uri]
 
-          node = Nokogiri::XML::Node.new(local_name, doc)
-          node.namespace = node.add_namespace_definition(prefix, namespace_uri)
+          node = doc.create_element(local_name)
+          node.add_namespace(prefix, namespace_uri)
 
           # Serialize attributes according to schema
           serialize_attributes_to_node(node, element, schema_def)
@@ -132,7 +132,7 @@ module Uniword
 
         # Serialize element attributes to node
         #
-        # @param node [Nokogiri::XML::Node] Node to add attributes to
+        # @param node [Moxml::Element] Node to add attributes to
         # @param element [Element] Element with attributes
         # @param schema_def [ElementDefinition] Schema definition
         def serialize_attributes_to_node(node, element, schema_def)
@@ -157,8 +157,8 @@ module Uniword
 
         # Serialize element children to node
         #
-        # @param doc [Nokogiri::XML::Document] XML document
-        # @param node [Nokogiri::XML::Node] Parent node
+        # @param doc [Moxml::Document] XML document
+        # @param node [Moxml::Element] Parent node
         # @param element [Element] Element with children
         # @param schema_def [ElementDefinition] Schema definition
         # @param options [Hash] Serialization options
@@ -190,11 +190,11 @@ module Uniword
 
         # Serialize a single child element to node
         #
-        # @param doc [Nokogiri::XML::Document] XML document
+        # @param doc [Moxml::Document] XML document
         # @param child [Element, Object] Child element or value
         # @param child_def [ChildDefinition] Child schema definition
         # @param options [Hash] Serialization options
-        # @return [Nokogiri::XML::Node, nil] Created node
+        # @return [Moxml::Element, nil] Created node
         def serialize_child_to_node(doc, child, child_def, options)
           # Get namespace prefix from tag (e.g., 'w:p' -> 'w')
           tag_parts = child_def.tag.split(":")
@@ -204,24 +204,21 @@ module Uniword
 
           if child_def.presence_only?
             # Presence-only element (e.g., <w:b/> for bold)
-            node = Nokogiri::XML::Node.new(local_name, doc)
-            node.namespace = node.add_namespace_definition(prefix,
-                                                           namespace_uri)
+            node = doc.create_element(local_name)
+            node.add_namespace(prefix, namespace_uri)
             node
           elsif child.is_a?(String)
             # Simple string value (e.g., text content)
-            node = Nokogiri::XML::Node.new(local_name, doc)
-            node.namespace = node.add_namespace_definition(prefix,
-                                                           namespace_uri)
+            node = doc.create_element(local_name)
+            node.add_namespace(prefix, namespace_uri)
             node.content = child
             node
           elsif child.is_a?(Uniword::Element)
             # Check if this is a TextElement that needs special handling
             if child.instance_of?(::Uniword::TextElement) && child.is_a?(Uniword::TextElement)
               # TextElement: serialize as element with text content
-              node = Nokogiri::XML::Node.new(local_name, doc)
-              node.namespace = node.add_namespace_definition(prefix,
-                                                             namespace_uri)
+              node = doc.create_element(local_name)
+              node.add_namespace(prefix, namespace_uri)
               node.content = child.content.to_s if child.content
               node
             else
@@ -238,9 +235,8 @@ module Uniword
             else
               # For properties without schema, create empty element
               # (will be filled with children if schema definition exists for element type)
-              node = Nokogiri::XML::Node.new(local_name, doc)
-              node.namespace = node.add_namespace_definition(prefix,
-                                                             namespace_uri)
+              node = doc.create_element(local_name)
+              node.add_namespace(prefix, namespace_uri)
 
               if child_def.has_attributes?
                 child_def.attributes.each do |attr_config|
@@ -256,9 +252,8 @@ module Uniword
             end
           elsif child_def.has_attributes?
             # Element with attributes but no child elements
-            node = Nokogiri::XML::Node.new(local_name, doc)
-            node.namespace = node.add_namespace_definition(prefix,
-                                                           namespace_uri)
+            node = doc.create_element(local_name)
+            node.add_namespace(prefix, namespace_uri)
 
             child_def.attributes.each do |attr_config|
               attr_def = AttributeDefinition.new(attr_config)
@@ -271,23 +266,20 @@ module Uniword
             node
           elsif child.is_a?(String)
             # Simple string value
-            node = Nokogiri::XML::Node.new(local_name, doc)
-            node.namespace = node.add_namespace_definition(prefix,
-                                                           namespace_uri)
+            node = doc.create_element(local_name)
+            node.add_namespace(prefix, namespace_uri)
             node.content = child
             node
           elsif child.is_a?(Uniword::TextElement)
             # TextElement or similar - get the content
-            node = Nokogiri::XML::Node.new(local_name, doc)
-            node.namespace = node.add_namespace_definition(prefix,
-                                                           namespace_uri)
+            node = doc.create_element(local_name)
+            node.add_namespace(prefix, namespace_uri)
             node.content = child.content.to_s if child.content
             node
           elsif child
             # Other value element - convert to string
-            node = Nokogiri::XML::Node.new(local_name, doc)
-            node.namespace = node.add_namespace_definition(prefix,
-                                                           namespace_uri)
+            node = doc.create_element(local_name)
+            node.add_namespace(prefix, namespace_uri)
             node.content = child.to_s
             node
           end

data/lib/uniword/ooxml/schema_library.rb

@@ -12,8 +12,8 @@ module Uniword
     # Namespace: http://schemas.openxmlformats.org/schemaLibrary/2006/main
     # Prefix: sl
     class SchemaLibEntry < Lutaml::Model::Serializable
-      attribute :uri, :string, default: -> { "" }
-      attribute :manifest_location, :string
+      attribute :uri, Types::SchemaLibraryVal, default: -> { "" }
+      attribute :manifest_location, Types::SchemaLibraryVal
 
       xml do
         element "schema"

data/lib/uniword/ooxml/types/characteristics_val.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Uniword
+  module Ooxml
+    module Types
+      # String type in the Additional Characteristics namespace.
+      class CharacteristicsVal < Lutaml::Model::Type::String
+        xml do
+          namespace Uniword::Ooxml::Namespaces::Characteristics
+        end
+      end
+    end
+  end
+end

data/lib/uniword/ooxml/types/schema_library_val.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Uniword
+  module Ooxml
+    module Types
+      # String type in the schemaLibrary namespace (sl:uri,
+      # sl:manifestLocation qualified attributes).
+      class SchemaLibraryVal < Lutaml::Model::Type::String
+        xml do
+          namespace Uniword::Ooxml::Namespaces::SchemaLibrary
+        end
+      end
+    end
+  end
+end

data/lib/uniword/ooxml/types/variant_types.rb

@@ -13,6 +13,14 @@ module Uniword
       module VariantTypes
         VT_NS = Uniword::Ooxml::Namespaces::VariantTypes
 
+        # String type for qualified vt: attributes (e.g. baseType on
+        # vector elements).
+        class VtAttr < Lutaml::Model::Type::String
+          xml do
+            namespace VT_NS
+          end
+        end
+
         # Base class for simple variant type values (text content only)
         class VTValue < Lutaml::Model::Serializable
           attribute :value, :string
@@ -259,7 +267,7 @@ module Uniword
 
         # vt:vector - Typed array of values
         class VtVector < Lutaml::Model::Serializable
-          attribute :base_type, :string
+          attribute :base_type, VtAttr
           attribute :size, :string
           attribute :lpwstr_values, VtLpwstr, collection: true
           attribute :lpstr_values, VtLpstr, collection: true
@@ -287,7 +295,7 @@ module Uniword
 
         # vt:array - Typed array with bounds
         class VtArray < Lutaml::Model::Serializable
-          attribute :base_type, :string
+          attribute :base_type, VtAttr
           attribute :size, :string
           attribute :l_bound, :string
           attribute :u_bound, :string

data/lib/uniword/ooxml/types/vt_attr.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Uniword
+  module Ooxml
+    module Types
+      module VariantTypes
+        # String type for qualified vt: attributes (e.g. baseType on
+        # vector elements).
+        class VtAttr < Lutaml::Model::Type::String
+          xml do
+            namespace VT_NS
+          end
+        end
+      end
+    end
+  end
+end

data/lib/uniword/ooxml/types/wml_int.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Uniword
+  module Ooxml
+    module Types
+      # Integer type in the WordProcessingML namespace (w:top, w:gutter,
+      # w:sz et al. qualified attributes).
+      class WmlInt < Lutaml::Model::Type::Integer
+        xml do
+          namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        end
+      end
+    end
+  end
+end

data/lib/uniword/ooxml/types/wml_val.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "lutaml/model"
+
+module Uniword
+  module Ooxml
+    module Types
+      # String type in the WordProcessingML namespace.
+      # Binds mapped attribute rules to their qualified (URI, local)
+      # identity — e.g. w:val on boolean/formatting elements — so
+      # strict adapters (Leptris) match exactly what DOCX emits.
+      class WmlVal < Lutaml::Model::Type::String
+        xml do
+          namespace Uniword::Ooxml::Namespaces::WordProcessingML
+        end
+      end
+    end
+  end
+end

data/lib/uniword/ooxml/types.rb

@@ -53,6 +53,18 @@ module Uniword
       # Relationships namespace type for r:embed/r:link cross-namespace attrs
       autoload :RelationshipId, "#{__dir__}/types/relationship_id"
 
+      # WordProcessingML namespace type for qualified w:val attributes
+      autoload :WmlVal, "#{__dir__}/types/wml_val"
+
+      # WordProcessingML namespace type for qualified integer attributes
+      autoload :WmlInt, "#{__dir__}/types/wml_int"
+
+      # schemaLibrary namespace type for sl: qualified attributes
+      autoload :SchemaLibraryVal, "#{__dir__}/types/schema_library_val"
+
+      # Additional Characteristics namespace type
+      autoload :CharacteristicsVal, "#{__dir__}/types/characteristics_val"
+
       # Variant Types (vt: namespace) for OLE property values
       autoload :VariantTypes, "#{__dir__}/types/variant_types"
 

data/lib/uniword/properties/alignment.rb

@@ -6,6 +6,10 @@ module Uniword
   module Properties
     # Namespaced custom type for alignment value
     class AlignmentValue < Lutaml::Model::Type::String
+      xml do
+        namespace Ooxml::Namespaces::WordProcessingML
+      end
+
       # Full ST_Jc enumeration from ECMA-376 (wml.xsd)
       VALUES = %w[
         start center end both mediumKashida distribute numTab

data/lib/uniword/properties/boolean_element_factory.rb

@@ -47,7 +47,7 @@ module Uniword
         klass = Class.new(Lutaml::Model::Serializable) do
           include BooleanElement
 
-          attribute :val, :string, default: nil
+          attribute :val, Ooxml::Types::WmlVal, default: nil
           include BooleanValSetter
 
           xml do

data/lib/uniword/properties/font_size.rb

@@ -6,6 +6,9 @@ module Uniword
   module Properties
     # Namespaced custom type for font size value
     class FontSizeValue < Lutaml::Model::Type::Integer
+      xml do
+        namespace Ooxml::Namespaces::WordProcessingML
+      end
     end
 
     # Font size element

data/lib/uniword/review/review_manager.rb

@@ -27,6 +27,8 @@ module Uniword
       def initialize(document)
         @document = document
         @accept_reject = AcceptReject.new
+        @resolver = RevisionResolver.new(document)
+        @resolver_hydrated = false
       end
 
       # --- Comments ---
@@ -141,26 +143,41 @@ module Uniword
 
       # Accept a single revision by ID.
       #
+      # Applies the decision to the document models (tracked-change
+      # nodes are spliced or removed) and keeps the facade list in
+      # sync.
+      #
       # @param revision_id [String] The revision ID to accept
       # @return [Boolean] true if accepted, false if not found
-      def accept(revision_id)
+      def accept(revision_id) # rubocop:disable Naming/PredicateMethod
         revision = tracked_changes.find_revision(revision_id)
         return false unless revision
 
-        @accept_reject.accept(revision)
+        if @resolver.ids.include?(revision_id.to_s)
+          @resolver.accept(revision_id)
+        else
+          @accept_reject.accept(revision)
+        end
         tracked_changes.remove_revision(revision_id)
         true
       end
 
       # Reject a single revision by ID.
       #
+      # Applies the decision to the document models and keeps the
+      # facade list in sync.
+      #
       # @param revision_id [String] The revision ID to reject
       # @return [Boolean] true if rejected, false if not found
-      def reject(revision_id)
+      def reject(revision_id) # rubocop:disable Naming/PredicateMethod
         revision = tracked_changes.find_revision(revision_id)
         return false unless revision
 
-        @accept_reject.reject(revision)
+        if @resolver.ids.include?(revision_id.to_s)
+          @resolver.reject(revision_id)
+        else
+          @accept_reject.reject(revision)
+        end
         tracked_changes.remove_revision(revision_id)
         true
       end
@@ -169,6 +186,8 @@ module Uniword
       #
       # @return [Integer] Number of changes accepted
       def accept_all
+        tracked_changes # hydrates the resolver's node registry
+        @resolver.ids.each { |id| @resolver.accept(id) }
         tracked_changes.accept_all
       end
 
@@ -176,6 +195,8 @@ module Uniword
       #
       # @return [Integer] Number of changes rejected
       def reject_all
+        tracked_changes # hydrates the resolver's node registry
+        @resolver.ids.each { |id| @resolver.reject(id) }
         tracked_changes.reject_all
       end
 
@@ -242,7 +263,10 @@ module Uniword
         end
       end
 
-      # Get or initialize TrackedChanges for the document.
+      # Get or initialize TrackedChanges for the document. On first
+      # access, parsed <w:ins>/<w:del> nodes are registered on the
+      # facade (via RevisionResolver) so listing and accept/reject
+      # reflect the document's real tracked changes.
       #
       # @return [Uniword::TrackedChanges] The tracked changes collection
       def tracked_changes
@@ -256,6 +280,11 @@ module Uniword
             tc
           end
         end
+        unless @resolver_hydrated
+          @resolver.hydrate(@tracked_changes)
+          @resolver_hydrated = true
+        end
+        @tracked_changes
       end
     end
   end

data/lib/uniword/review/revision_resolver.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module Uniword
+  module Review
+    # Bridges parsed tracked-change nodes (<w:ins>/<w:del> on
+    # paragraphs) to the TrackedChanges facade and applies
+    # accept/reject decisions to the document models.
+    #
+    # Hydration walks the body (tables and SDT content included, via
+    # ParagraphWalker) and registers one facade Revision per node,
+    # keyed by the OOXML revision id (w:id). Decisions then mutate
+    # the models:
+    #
+    # - accept insert  → splice wrapped runs into the paragraph
+    # - reject insert  → remove the node
+    # - accept delete  → remove the node (deleted content goes away)
+    # - reject delete  → splice runs back, delText converted to t
+    #
+    # element_order arrays are updated alongside the collections so
+    # serialization keeps the runs at the revision's position.
+    class RevisionResolver
+      # @param document [Wordprocessingml::DocumentRoot]
+      def initialize(document)
+        @document = document
+        @nodes = {}
+      end
+
+      # Register every parsed ins/del node on the facade.
+      #
+      # @param tracked_changes [Uniword::TrackedChanges]
+      # @return [Uniword::TrackedChanges]
+      def hydrate(tracked_changes)
+        each_tracked_node do |paragraph, node|
+          id = node.id.to_s
+          next if id.empty? || @nodes.key?(id)
+
+          @nodes[id] = [paragraph, node]
+          tracked_changes.add_revision(facade_revision_for(node))
+        end
+        tracked_changes
+      end
+
+      # Registered revision ids, in document order.
+      #
+      # @return [Array<String>]
+      def ids
+        @nodes.keys
+      end
+
+      # Accept one revision: keep inserted content / drop deleted
+      # content.
+      #
+      # @param revision_id [String]
+      # @return [Boolean] true when the revision was found and applied
+      def accept(revision_id) # rubocop:disable Naming/PredicateMethod
+        paragraph, node = @nodes[revision_id.to_s]
+        return false unless paragraph
+
+        if insertion?(node)
+          splice_into_paragraph(paragraph, node, node.runs)
+        else
+          remove_node(paragraph, node)
+        end
+        @nodes.delete(revision_id.to_s)
+        true
+      end
+
+      # Reject one revision: drop inserted content / restore deleted
+      # content.
+      #
+      # @param revision_id [String]
+      # @return [Boolean] true when the revision was found and applied
+      def reject(revision_id) # rubocop:disable Naming/PredicateMethod
+        paragraph, node = @nodes[revision_id.to_s]
+        return false unless paragraph
+
+        if insertion?(node)
+          remove_node(paragraph, node)
+        else
+          restored = node.runs.map { |run| restore_run_text(run) }
+          splice_into_paragraph(paragraph, node, restored)
+        end
+        @nodes.delete(revision_id.to_s)
+        true
+      end
+
+      private
+
+      def insertion?(node)
+        node.is_a?(Wordprocessingml::Insertion)
+      end
+
+      def facade_revision_for(node)
+        Uniword::Revision.new(
+          type: insertion?(node) ? :insert : :delete,
+          revision_id: node.id.to_s,
+          author: node.author,
+          date: node.date,
+          text: node.text,
+        )
+      end
+
+      def each_tracked_node(&block)
+        containers = [@document.body].compact
+        FindReplace::ParagraphWalker.each_paragraph(containers) do |p|
+          p.insertions.each { |node| yield(p, node) }
+          p.deletions.each { |node| yield(p, node) }
+        end
+      end
+
+      def splice_into_paragraph(paragraph, node, runs)
+        tag = node_tag(node)
+        collection = tracked_collection(paragraph, node)
+        index = collection.index(node)
+
+        paragraph.runs.concat(runs)
+        collection.delete(node)
+        replace_order_entry(paragraph, tag, index, runs.size)
+      end
+
+      def remove_node(paragraph, node)
+        tag = node_tag(node)
+        collection = tracked_collection(paragraph, node)
+        index = collection.index(node)
+
+        collection.delete(node)
+        replace_order_entry(paragraph, tag, index, 0)
+      end
+
+      # Convert a deleted run's delText back into live text so a
+      # rejected deletion re-enters the document as content.
+      def restore_run_text(run)
+        deleted = run.del_text
+        if deleted
+          run.text = [] if run.text.nil?
+          run.text << Wordprocessingml::Text.new(content: deleted.content)
+          run.del_text = nil
+          retag_order_entry(run, "delText", "t")
+        end
+        run
+      end
+
+      def node_tag(node)
+        insertion?(node) ? "ins" : "del"
+      end
+
+      def tracked_collection(paragraph, node)
+        insertion?(node) ? paragraph.insertions : paragraph.deletions
+      end
+
+      # Replace the index-th `tag` entry in element_order with `count`
+      # run entries (count 0 removes it). Parsed models carry
+      # element_order; built models serialize by collection order.
+      def replace_order_entry(model, tag, index, count)
+        order = Ooxml::ElementOrder.mutable_order(model)
+        return unless order
+        return unless index
+
+        position = nth_entry_index(order, tag, index)
+        return unless position
+
+        entries = Array.new(count) { xml_entry("r") }
+        order[position, 1] = entries
+      end
+
+      def retag_order_entry(model, old_tag, new_tag)
+        order = Ooxml::ElementOrder.mutable_order(model)
+        return unless order
+
+        position = nth_entry_index(order, old_tag, 0)
+        order[position] = xml_entry(new_tag) if position
+      end
+
+      def nth_entry_index(order, tag, nth)
+        seen = -1
+        order.each_with_index do |entry, i|
+          next unless entry.name == tag
+
+          seen += 1
+          return i if seen == nth
+        end
+        nil
+      end
+
+      def xml_entry(name)
+        Lutaml::Xml::Element.new("Element", name)
+      end
+    end
+  end
+end

data/lib/uniword/review.rb

@@ -14,6 +14,7 @@ module Uniword
   module Review
     autoload :AcceptReject, "uniword/review/accept_reject"
     autoload :ReviewManager, "uniword/review/review_manager"
+    autoload :RevisionResolver, "uniword/review/revision_resolver"
     autoload :InteractiveReview, "uniword/review/interactive_review"
   end
 end

data/lib/uniword/revision.rb

@@ -35,13 +35,13 @@ module Uniword
   # @see TrackedChanges For revision collection management
   class Revision < Lutaml::Model::Serializable
     # Unique revision identifier
-    attribute :revision_id, :string
+    attribute :revision_id, Ooxml::Types::WmlVal
 
     # Author name
-    attribute :author, :string
+    attribute :author, Ooxml::Types::WmlVal
 
     # Revision date/time
-    attribute :date, :string
+    attribute :date, Ooxml::Types::WmlVal
 
     # OOXML namespace configuration
     xml do

data/lib/uniword/serialization/ooxml_serializer.rb

@@ -18,12 +18,12 @@ module Uniword
         document.to_xml(encoding: "UTF-8", prefix: true)
       end
 
-      # Serialize a document to XML and return as a Nokogiri document
+      # Serialize a document to XML and return as a Moxml document
       #
       # @param document [DocumentRoot] The document to serialize
-      # @return [Nokogiri::XML::Document] The serialized document
+      # @return [Moxml::Document] The serialized document
       def serialize_to_doc(document)
-        Nokogiri::XML(serialize(document))
+        Moxml.parse(serialize(document))
       end
     end
   end