uniword 1.6.0 → 1.7.0

data/lib/uniword/find_replace/paragraph_walker.rb

@@ -2,15 +2,21 @@
 
 module Uniword
   module FindReplace
-    # Walks an enumerable of containers (Body, TableCell, SDT, ...)
-    # and yields every Paragraph reachable. Used by all scopes that
-    # traverse paragraph-bearing parts (body, headers, footers,
-    # footnotes, endnotes, comments).
+    # Walks an enumerable of containers (Body, TableCell, Header,
+    # Footer, Footnote, Endnote, Comment) and yields every Paragraph
+    # reachable. Used by all scopes that traverse paragraph-bearing
+    # parts (body, headers, footers, footnotes, endnotes, comments).
+    #
+    # Container classes map different subsets of OOXML block-level
+    # content, so dispatch is explicit per class (mirrors
+    # Docx::DocumentStatistics):
+    # - Body maps paragraphs, tables, and structured document tags
+    # - TableCell, Header, Footer map paragraphs and tables
+    # - Footnote, Endnote, Comment map paragraphs only
     module ParagraphWalker
       module_function
 
-      # @param containers [Enumerable<#paragraphs, #tables,
-      #   #structured_document_tags>] containers to walk
+      # @param containers [Enumerable<#paragraphs>] containers to walk
       # @yieldparam paragraph [Wordprocessingml::Paragraph]
       # @return [void]
       def each_paragraph(containers, &block)
@@ -23,13 +29,37 @@ module Uniword
       # @yieldparam paragraph [Wordprocessingml::Paragraph]
       # @return [void]
       def walk_container(container, &block)
-        container.paragraphs&.each(&block)
-        walk_tables(container.tables, &block) if container.tables
-        if container.structured_document_tags
-          walk_sdts(container.structured_document_tags, &block)
+        case container
+        when Wordprocessingml::Body
+          walk_body(container, &block)
+        else
+          walk_non_body(container, &block)
         end
       end
 
+      # Body is the only container class that maps structured
+      # document tags.
+      def walk_body(body, &block)
+        body.paragraphs&.each(&block)
+        walk_tables(body.tables, &block)
+        walk_sdts(body.structured_document_tags, &block)
+      end
+
+      # TableCell, Header, and Footer map tables; Footnote, Endnote,
+      # and Comment map paragraphs only.
+      def walk_non_body(container, &block)
+        container.paragraphs&.each(&block)
+        return unless table_bearing?(container)
+
+        walk_tables(container.tables, &block)
+      end
+
+      def table_bearing?(container)
+        container.is_a?(Wordprocessingml::TableCell) ||
+          container.is_a?(Wordprocessingml::Header) ||
+          container.is_a?(Wordprocessingml::Footer)
+      end
+
       def walk_tables(tables, &block)
         tables.each do |table|
           walk_table_rows(table, &block) if table.rows
@@ -48,13 +78,20 @@ module Uniword
         end
       end
 
+      # SDT content (sdtContent) is itself a block-level container
+      # with paragraphs, tables, and nested SDTs.
       def walk_sdts(sdts, &block)
         sdts.each do |sdt|
-          sdt.paragraphs&.each(&block)
+          next unless sdt.content
+
+          sdt.content.paragraphs&.each(&block)
+          walk_tables(sdt.content.tables, &block)
+          walk_sdts(sdt.content.sdts, &block)
         end
       end
 
-      private_class_method :walk_container, :walk_tables, :walk_table_rows,
+      private_class_method :walk_container, :walk_body, :walk_non_body,
+                           :table_bearing?, :walk_tables, :walk_table_rows,
                            :walk_table_cells, :walk_sdts
     end
   end

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/infrastructure/mime_packager.rb

@@ -92,19 +92,12 @@ module Uniword
         # Empty line separating headers from body
         lines << ""
 
-        # Body — encode if needed
+        # Body — encode if needed (part content is always decoded)
         encoding = part.content_transfer_encoding
         if encoding == "quoted-printable"
-          # Use decoded_content to avoid double-encoding on round-trip
-          body = quoted_printable_encode(part.decoded_content)
+          body = quoted_printable_encode(part.raw_content)
         elsif encoding == "base64"
-          begin
-            # Decoded content (round-trip: raw_content is already base64)
-            body = Base64.strict_encode64(part.decoded_content)
-          rescue ArgumentError
-            # New part: raw_content is raw binary data
-            body = Base64.strict_encode64(part.raw_content)
-          end
+          body = Base64.strict_encode64(part.raw_content)
           body = body.gsub(/.{1,76}/, "\\0\r\n").rstrip
         else
           body = part.raw_content

data/lib/uniword/infrastructure/mime_parser.rb

@@ -96,11 +96,33 @@ module Uniword
         mime_part.content_location = content_location
         mime_part.content_transfer_encoding = encoding
         mime_part.content_id = content_id&.gsub(/[<>]/, "")
-        mime_part.raw_content = body.rstrip
+        mime_part.decoded_content = decode_body(body.rstrip, encoding)
 
         mime_part
       end
 
+      # Decode a wire body into its content, per the declared
+      # Content-Transfer-Encoding. Stored content is always decoded.
+      # Tolerant of real-world corruption (Word truncates some base64
+      # tails), so base64 uses the non-strict decoder.
+      def decode_body(body, encoding)
+        case encoding&.downcase
+        when "base64"
+          Base64.decode64(body)
+        when "quoted-printable"
+          # Decode in BINARY so hex escapes map 1:1 to bytes; single-pass
+          # gsub, so an already-decoded byte is never re-decoded.
+          body.force_encoding("BINARY")
+            .gsub(/=\r?\n/, "")
+            .gsub(/=([0-9A-Fa-f]{2})/) do
+              [::Regexp.last_match(1).hex].pack("C")
+            end
+            .force_encoding("UTF-8")
+        else
+          body&.force_encoding("UTF-8") || body
+        end
+      end
+
       # Create a typed MimePart based on content type.
       def create_typed_part(content_type)
         return nil unless content_type

data/lib/uniword/math/plurimath_adapter.rb

@@ -34,7 +34,7 @@ module Uniword
 
       # Create a MathEquation from OMML XML
       #
-      # @param omml_xml [String, Nokogiri::XML::Node] OMML XML content
+      # @param omml_xml [String, Moxml::Node] OMML XML content
       # @return [MathEquation] New equation instance with parsed formula
       #
       # @example Parse OMML
@@ -94,7 +94,7 @@ module Uniword
 
       # Parse OMML to Plurimath formula
       #
-      # @param node [Nokogiri::XML::Node] OMML node
+      # @param node [Moxml::Node] OMML node
       # @return [Plurimath::Math::Formula] Parsed formula
       #
       # @api private
@@ -131,7 +131,7 @@ module Uniword
 
       # Determine if equation is inline or block display
       #
-      # @param node [Nokogiri::XML::Node] OMML node
+      # @param node [Moxml::Node] OMML node
       # @return [String] "inline" or "block"
       #
       # @api private
@@ -143,7 +143,7 @@ module Uniword
 
       # Extract equation properties from OMML
       #
-      # @param node [Nokogiri::XML::Node] OMML node
+      # @param node [Moxml::Node] OMML node
       # @return [Hash] Extracted properties
       #
       # @api private
@@ -220,21 +220,26 @@ module Uniword
       #
       # @api private
       def self.wrap_block_equation(omml_content, equation)
-        builder = Nokogiri::XML::Builder.new do |xml|
-          xml["m"].oMathPara("xmlns:m" => OMML_NAMESPACE) do
-            # Add paragraph properties if needed
-            if equation.alignment || equation.break_enabled
-              xml["m"].oMathParaPr do
-                xml["m"].jc("m:val" => equation.alignment) if equation.alignment
-              end
-            end
+        doc = Moxml.new.create_document
+        para = doc.create_element("m:oMathPara")
+        para.add_namespace("m", OMML_NAMESPACE)
+        doc.root = para
 
-            # Add the math content
-            xml.parent << Nokogiri::XML.fragment(omml_content)
+        # Add paragraph properties if needed
+        if equation.alignment || equation.break_enabled
+          props = doc.create_element("m:oMathParaPr")
+          if equation.alignment
+            jc = doc.create_element("m:jc")
+            jc["m:val"] = equation.alignment
+            props.add_child(jc)
           end
+          para.add_child(props)
         end
 
-        builder.to_xml
+        # Add the math content
+        para.add_child(Moxml.parse(omml_content).root)
+
+        doc.to_xml
       end
 
       # Format OMML output
@@ -248,33 +253,32 @@ module Uniword
       def self.format_omml(omml, options = {})
         return omml unless options[:pretty]
 
-        doc = Nokogiri::XML(omml)
-        doc.to_xml(indent: 2)
+        Moxml.parse(omml).to_xml(indent: 2)
       end
 
       # Parse XML node from string or node
       #
-      # @param xml [String, Nokogiri::XML::Node] XML input
-      # @return [Nokogiri::XML::Node] Parsed node
+      # @param xml [String, Moxml::Node] XML input
+      # @return [Moxml::Node] Parsed node
       #
       # @api private
       def self.parse_xml_node(xml)
         case xml
-        when Nokogiri::XML::Node
+        when Moxml::Node
           xml
         when String
-          doc = Nokogiri::XML(xml)
+          doc = Moxml.parse(xml)
           doc.root || raise(ArgumentError, "Invalid XML: no root element")
         else
           raise ArgumentError,
-                "Expected String or Nokogiri::XML::Node, got #{xml.class}"
+                "Expected String or Moxml::Node, got #{xml.class}"
         end
       end
 
       # Extract the math node (m:oMath) from container
       #
-      # @param node [Nokogiri::XML::Node] OMML node (could be oMath or oMathPara)
-      # @return [Nokogiri::XML::Node] The m:oMath node
+      # @param node [Moxml::Node] OMML node (could be oMath or oMathPara)
+      # @return [Moxml::Node] The m:oMath node
       #
       # @api private
       def self.extract_math_node(node)

data/lib/uniword/math_equation.rb

@@ -52,7 +52,7 @@ module Uniword
 
     # Create a MathEquation from OMML XML
     #
-    # @param omml_xml [String, Nokogiri::XML::Node] OMML XML content
+    # @param omml_xml [String, Moxml::Node] OMML XML content
     # @return [MathEquation] New equation instance
     #
     # @example

data/lib/uniword/mhtml/html_part.rb

@@ -7,26 +7,26 @@ module Uniword
     # Contains the Word HTML document with embedded XML metadata
     # (DocumentProperties, WordDocument settings, LatentStyles).
     class HtmlPart < MimePart
-      # Parse the decoded HTML with Nokogiri
+      # Parse the decoded HTML with Moxml (Leptris HTML parser)
       def html_document
-        @html_document ||= Nokogiri::HTML(decoded_content)
+        @html_document ||= Moxml.new.parse_html(decoded_content)
       end
 
       # Extract the <head> element as string
       def head_html
-        node = html_document.at_css("head")
-        node ? node.to_s : ""
+        node = html_document.at_xpath(".//head")
+        node ? node.to_xml : ""
       end
 
       # Extract the <body> element inner HTML
       def body_html
-        node = html_document.at_css("body")
-        node ? node.inner_html : ""
+        node = html_document.at_xpath(".//body")
+        node ? node.children.map(&:to_xml).join : ""
       end
 
       # Extract inline CSS styles from <style> tags
       def css_styles
-        html_document.css("style").map(&:content).join("\n")
+        html_document.xpath(".//style").map(&:content).join("\n")
       end
 
       # Extract DocumentProperties XML from HTML head comments.
@@ -56,9 +56,15 @@ module Uniword
                            "urn:schemas-microsoft-com:office:word", "w")
       end
 
+      # The document head element.
+      def head_element
+        html_document.at_xpath(".//head")
+      end
+
       # Extract all <xml> blocks from head
       def xml_blocks
-        html_document.at_css("head")&.xpath("comment()")&.filter_map do |comment|
+        head = head_element
+        head&.xpath("comment()")&.filter_map do |comment|
           text = comment.text
           ::Regexp.last_match(1).strip if text =~ %r{<xml>(.*?)</xml>}m
         end || []
@@ -82,23 +88,23 @@ module Uniword
       # This method finds the requested root element and wraps it
       # with proper namespace declarations for lutaml-model.
       def extract_office_xml(element_name, namespace_uri, prefix)
-        head = html_document.at_css("head")
+        head = head_element
         return nil unless head
 
         head.xpath("comment()").each do |comment|
           text = comment.text
-          next unless text.include?("<#{prefix}:#{element_name}")
+          tag = "#{prefix}:#{element_name}"
+          next unless text.include?("<#{tag}")
 
           # Extract the specific element with its content
-          pattern = %r{(<#{prefix}:#{element_name}[^>]*>.*?</#{prefix}:#{element_name}>)}m
+          pattern = %r{(<#{tag}[^>]*>.*?</#{tag}>)}m
           next unless text =~ pattern
 
           xml = ::Regexp.last_match(1)
           # Ensure namespace declaration is present
           ns_decl = "xmlns:#{prefix}=\"#{namespace_uri}\""
           unless xml.include?(ns_decl)
-            xml = xml.sub(/(<#{prefix}:#{element_name})/,
-                          "\\1 #{ns_decl}")
+            xml = xml.sub(/(<#{tag})/, "\\1 #{ns_decl}")
           end
           return xml
         end

data/lib/uniword/mhtml/math_converter.rb

@@ -111,45 +111,51 @@ module Uniword
       #
       # Identifies math elements by tag name or special markers.
       #
-      # @param element [Nokogiri::XML::Element] The HTML element
+      # @param element [Moxml::Element] The HTML element
       # @return [Boolean] true if element contains math content
       #
       # @example Check if element is math
       #   is_math = MathConverter.math_element?(element)
       def self.math_element?(element)
-        return false unless element.is_a?(Nokogiri::XML::Element)
+        return false unless element.is_a?(Moxml::Element)
 
         math_tags = %w[math mml:math m:oMath m:oMathPara]
         return true if math_tags.include?(element.name)
-        return true if element["class"]&.include?("math")
-        return true if element["data-mathml"]
 
-        false
+        css_class = attribute_value(element, "class").to_s
+        return true if css_class.include?("math")
+
+        !attribute_value(element, "data-mathml").nil?
       end
 
       # Extract math content from element.
       #
       # Extracts the mathematical content from various element types.
       #
-      # @param element [Nokogiri::XML::Element] The HTML element
+      # @param element [Moxml::Element] The HTML element
       # @return [Hash] Hash with :type and :content
       #
       # @example Extract math from element
       #   math = MathConverter.extract_math(element)
       #   # => { type: :mathml, content: "<math>...</math>" }
       def self.extract_math(element)
-        if element["data-mathml"]
-          { type: :mathml, content: element["data-mathml"] }
+        if (mathml = attribute_value(element, "data-mathml"))
+          { type: :mathml, content: mathml }
         elsif /^(math|mml:math)$/.match?(element.name)
-          { type: :mathml, content: element.to_s }
+          { type: :mathml, content: element.to_xml }
         elsif /^m:(oMath|oMathPara)$/.match?(element.name)
-          { type: :omml, content: element.to_s }
-        elsif element["class"]&.include?("asciimath")
+          { type: :omml, content: element.to_xml }
+        elsif attribute_value(element, "class").to_s.include?("asciimath")
           { type: :asciimath, content: element.text }
         else
-          { type: :unknown, content: element.to_s }
+          { type: :unknown, content: element.to_xml }
         end
       end
+
+      # Read an attribute value from a Moxml element.
+      def self.attribute_value(element, name)
+        element.attribute(name)&.value
+      end
     end
   end
 end

data/lib/uniword/mhtml/mime_part.rb

@@ -7,7 +7,10 @@ module Uniword
     # Base class for MIME parts in an MHTML document.
     #
     # Each MIME part has headers (Content-Type, Content-Location,
-    # Content-Transfer-Encoding) and a body (raw content).
+    # Content-Transfer-Encoding) and a body (raw_content, always in
+    # DECODED form: the wire encoding declared by
+    # content_transfer_encoding is applied by MimePackager and removed
+    # by MimeParser, never here).
     #
     # Subclasses: HtmlPart, XmlPart, ImagePart, FileListPart, HeaderPart
     class MimePart < Lutaml::Model::Serializable
@@ -18,21 +21,7 @@ module Uniword
       attribute :raw_content, :string
 
       def decoded_content
-        case content_transfer_encoding&.downcase
-        when "base64"
-          Base64.strict_decode64(raw_content.gsub(/\s+/, ""))
-        when "quoted-printable"
-          # Work in BINARY encoding to avoid gsub encoding conflicts,
-          # then force UTF-8 at the end. Use .b to get BINARY encoding
-          # without altering bytes.
-          content = raw_content.dup.force_encoding("BINARY")
-          content
-            .gsub(/=\r?\n/, "")
-            .gsub(/=([0-9A-Fa-f]{2})/) { [::Regexp.last_match(1).hex].pack("C") }
-            .force_encoding("UTF-8")
-        else
-          raw_content
-        end
+        raw_content
       end
 
       def decoded_content=(value)

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/element_order.rb

@@ -77,6 +77,27 @@ module Uniword
       end
       module_function :insert_once
 
+      # Reposition an existing singleton entry after (or before) the
+      # given anchor. No-op when the entry or model order is absent.
+      # Falls back to end (after: missing) or start (before: missing).
+      #
+      # @param model [Lutaml::Model::Serializable] model to mutate
+      # @param name [String] element name to move
+      # @param after [String, nil] place after this element name
+      # @param before [String, nil] place before this element name
+      # @return [Array, nil] the mutated order
+      def move_once(model, name, after: nil, before: nil)
+        order = mutable_order(model)
+        return unless order
+
+        entry = order.find { |e| e.name == name }
+        return unless entry
+
+        order.delete_at(order.index { |e| e.name == name })
+        order.insert(insertion_index(order, after, before, nil), entry)
+      end
+      module_function :move_once
+
       # @return [Integer] index for the insert
       def insertion_index(order, after, before, position)
         if after