uniword 1.6.1 → 1.7.0

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/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

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