uniword 1.5.4 → 1.6.1

data/lib/uniword/find_replace/scope.rb

@@ -59,16 +59,19 @@ module Uniword
 
       # Walk every paragraph in `containers` and yield each run's
       # text elements. Shared by body / headers / footers / footnotes
-      # / endnotes / comments scopes.
+      # / endnotes / comments scopes. Runs inside tracked insertions
+      # are live content and included; runs inside deletions are
+      # deleted content and left untouched.
       #
-      # @param containers [Enumerable<#paragraphs, #tables,
-      #   #structured_document_tags>]
+      # @param containers [Enumerable<#paragraphs>]
       # @yieldparam text_element [Wordprocessingml::Text]
       # @yieldparam accessor [TextAccessor]
       # @return [void]
       def each_text_in_containers(containers)
         ParagraphWalker.each_paragraph(containers) do |paragraph|
-          paragraph.runs&.each do |run|
+          runs = paragraph.runs +
+            paragraph.insertions.flat_map(&:runs)
+          runs.each do |run|
             each_text_in_run(run) { |*a| yield(*a) }
           end
         end

data/lib/uniword/mhtml/xml_part.rb

@@ -5,9 +5,9 @@ module Uniword
     # XML MIME part — filelist.xml, props*.xml, colorschememapping.xml, etc.
     class XmlPart < MimePart
       def xml_content
-        @xml_content ||= Nokogiri::XML(decoded_content) { |config| config.strict.noblanks }
-      rescue Nokogiri::XML::SyntaxError
-        @xml_content ||= Nokogiri::XML(decoded_content)
+        @xml_content ||= Moxml.parse(decoded_content)
+      rescue Moxml::ParseError
+        @xml_content ||= Moxml.parse(decoded_content)
       end
 
       def to_xml

data/lib/uniword/ooxml/additional_characteristics.rb

@@ -11,10 +11,10 @@ module Uniword
     #
     # Namespace: http://schemas.openxmlformats.org/officeDocument/2006/characteristics
     class Characteristic < Lutaml::Model::Serializable
-      attribute :name, :string
-      attribute :relation, :string
-      attribute :val, :string
-      attribute :vocabulary, :string
+      attribute :name, Types::CharacteristicsVal
+      attribute :relation, Types::CharacteristicsVal
+      attribute :val, Types::CharacteristicsVal
+      attribute :vocabulary, Types::CharacteristicsVal
 
       xml do
         element "characteristic"

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

data/lib/uniword/theme/theme_xml_parser.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "nokogiri"
-
 module Uniword
   module Themes
     # Parses theme XML files into Theme models
@@ -26,7 +24,7 @@ module Uniword
       # @return [Theme] Parsed theme
       # @raise [ArgumentError] if XML is invalid or missing theme element
       def parse(xml)
-        doc = Nokogiri::XML(xml)
+        doc = Moxml.parse(xml)
         theme_node = doc.at_xpath("//a:theme", THEME_NS)
 
         unless theme_node

data/lib/uniword/validation/opc_validator.rb

@@ -1,7 +1,6 @@
 # frozen_string_literal: true
 
 require "zip"
-require "nokogiri"
 
 module Uniword
   module Validation
@@ -107,7 +106,7 @@ module Uniword
         ct_entry = zip.find_entry("[Content_Types].xml")
         return unless ct_entry
 
-        ct_doc = Nokogiri::XML(ct_entry.get_input_stream.read, &:strict)
+        ct_doc = Moxml.parse(ct_entry.get_input_stream.read)
 
         # Get declared extensions
         declared_exts = ct_doc.xpath("//xmlns:Default", "xmlns" => CT_NS)
@@ -137,7 +136,7 @@ module Uniword
             suggestion: "Add a Default or Override entry in [Content_Types].xml.",
           )
         end
-      rescue Nokogiri::XML::SyntaxError => e
+      rescue Moxml::ParseError => e
         issues << Report::ValidationIssue.new(
           severity: "error",
           code: "OPC-008",
@@ -155,7 +154,7 @@ module Uniword
       end
 
       def check_relationship_file(zip, entry, issues)
-        doc = Nokogiri::XML(entry.get_input_stream.read)
+        doc = Moxml.parse(entry.get_input_stream.read)
 
         base_dir = compute_base_dir(entry.name)
 
@@ -181,7 +180,7 @@ module Uniword
                         "from the package. Remove the relationship or add the part.",
           )
         end
-      rescue Nokogiri::XML::SyntaxError => e
+      rescue Moxml::ParseError => e
         issues << Report::ValidationIssue.new(
           severity: "error",
           code: "OPC-008",
@@ -195,8 +194,8 @@ module Uniword
 
         xml_entries.each do |entry|
           content = entry.get_input_stream.read
-          Nokogiri::XML(content, &:strict)
-        rescue Nokogiri::XML::SyntaxError => e
+          Moxml.parse(content)
+        rescue Moxml::ParseError => e
           issues << Report::ValidationIssue.new(
             severity: "error",
             code: "OPC-008",

data/lib/uniword/validation/rules/document_context.rb

@@ -29,7 +29,7 @@ module Uniword
           @path = path
           @zip = nil
           @parsed_parts = {}
-          @moxml = Moxml.new(:nokogiri)
+          @moxml = Moxml.new
         end
 
         # Context type used by the Engine to select rules.
@@ -139,7 +139,7 @@ module Uniword
           raw = part_raw(rels_path)
           return [] unless raw
 
-          doc = Nokogiri::XML(raw)
+          doc = Moxml.parse(raw)
           doc.xpath("//xmlns:Relationship", "xmlns" => RELS_NS).map do |rel|
             {
               id: rel["Id"],
@@ -157,7 +157,7 @@ module Uniword
           raw = part_raw("[Content_Types].xml")
           return {} unless raw
 
-          doc = Nokogiri::XML(raw)
+          doc = Moxml.parse(raw)
           types = {}
 
           doc.xpath("//xmlns:Default", "xmlns" => CT_NS).each do |node|