uniword 1.6.1 → 1.7.0

data/lib/uniword/streaming_parser.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require "nokogiri"
-
 module Uniword
   # Streaming parser for large DOCX documents.
   #
@@ -48,21 +46,20 @@ module Uniword
     # @param zip_content [Hash] Extracted ZIP content from DOCX
     # @return [Document] The parsed document
     def parse_streaming(zip_content)
-      document = Document.new
+      document = Wordprocessingml::DocumentRoot.new
       document_xml = zip_content["word/document.xml"]
 
       return document unless document_xml
 
-      # Use Nokogiri's SAX parser for streaming
+      # Stream via Moxml's SAX parser
       handler = DocumentSaxHandler.new(document, @paragraph_limit, @table_limit)
-      parser = Nokogiri::XML::SAX::Parser.new(handler)
-      parser.parse(document_xml)
+      Moxml.new.config.adapter.sax_parse(document_xml, handler)
 
       document
     end
 
     # SAX handler for streaming document parsing
-    class DocumentSaxHandler < Nokogiri::XML::SAX::Document
+    class DocumentSaxHandler < Moxml::SAX::Handler
       attr_reader :document
 
       def initialize(document, paragraph_limit = nil, table_limit = nil)
@@ -86,8 +83,8 @@ module Uniword
       end
 
       # Called when an element starts
-      def start_element(name, attributes = [])
-        attrs = attributes.to_h
+      def on_start_element(name, _attributes = {}, _namespaces = {})
+        name = local_name(name)
         @element_stack.push(name)
 
         case name
@@ -96,7 +93,7 @@ module Uniword
         when "r"
           start_run
         when "t"
-          start_text(attrs)
+          start_text
         when "tbl"
           start_table
         when "tr"
@@ -109,7 +106,8 @@ module Uniword
       end
 
       # Called when an element ends
-      def end_element(name)
+      def on_end_element(name)
+        name = local_name(name)
         @element_stack.pop
 
         case name
@@ -131,7 +129,7 @@ module Uniword
       end
 
       # Called when text content is encountered
-      def characters(string)
+      def on_characters(string)
         return unless @current_text
 
         @current_text << string
@@ -139,6 +137,11 @@ module Uniword
 
       private
 
+      # Strip any namespace prefix from a SAX element name.
+      def local_name(name)
+        name.split(":").last
+      end
+
       # Check if we've hit paragraph limit
       def paragraph_limit_reached?
         @paragraph_limit && @paragraph_count >= @paragraph_limit
@@ -153,7 +156,7 @@ module Uniword
       def start_paragraph
         return if paragraph_limit_reached?
 
-        @current_paragraph = Paragraph.new
+        @current_paragraph = Wordprocessingml::Paragraph.new
         @paragraph_count += 1
       end
 
@@ -176,7 +179,7 @@ module Uniword
       def start_run
         return unless @current_paragraph
 
-        @current_run = Run.new
+        @current_run = Wordprocessingml::Run.new
       end
 
       # End parsing a run
@@ -188,7 +191,7 @@ module Uniword
       end
 
       # Start parsing text
-      def start_text(_attrs)
+      def start_text
         return unless @current_run
 
         @current_text = +""
@@ -198,8 +201,7 @@ module Uniword
       def end_text
         return unless @current_text && @current_run
 
-        text_element = TextElement.new(content: @current_text)
-        @current_run.text_element = text_element
+        @current_run.text = [Wordprocessingml::Text.new(content: @current_text)]
         @current_text = nil
       end
 
@@ -207,7 +209,7 @@ module Uniword
       def start_table
         return if table_limit_reached?
 
-        @current_table = Table.new
+        @current_table = Wordprocessingml::Table.new
         @table_count += 1
       end
 
@@ -223,7 +225,7 @@ module Uniword
       def start_table_row
         return unless @current_table
 
-        @current_row = TableRow.new
+        @current_row = Wordprocessingml::TableRow.new
       end
 
       # End parsing a table row
@@ -238,7 +240,7 @@ module Uniword
       def start_table_cell
         return unless @current_row
 
-        @current_cell = TableCell.new
+        @current_cell = Wordprocessingml::TableCell.new
       end
 
       # End parsing a table cell

data/lib/uniword/theme/theme_xml_parser.rb

@@ -61,7 +61,7 @@ module Uniword
 
       # Parse color scheme from XML
       #
-      # @param node [Nokogiri::XML::Element] Color scheme node
+      # @param node [Moxml::Element] Color scheme node
       # @return [ColorScheme] Parsed color scheme
       def parse_color_scheme(node)
         scheme = ColorScheme.new
@@ -138,7 +138,7 @@ module Uniword
       # - schemeClr: Reference to another theme color
       # - prstClr: Preset color name
       #
-      # @param node [Nokogiri::XML::Element] Color node
+      # @param node [Moxml::Element] Color node
       # @return [String, nil] RGB hex value (6 characters, no #)
       def extract_color_value(node)
         # Try sRGB color first (direct RGB value)
@@ -180,7 +180,7 @@ module Uniword
 
       # Parse font scheme from XML
       #
-      # @param node [Nokogiri::XML::Element] Font scheme node
+      # @param node [Moxml::Element] Font scheme node
       # @return [FontScheme] Parsed font scheme
       def parse_font_scheme(node)
         scheme = FontScheme.new

data/lib/uniword/transformation/html_element_builder.rb

@@ -2,7 +2,7 @@
 
 module Uniword
   module Transformation
-    # Builds OOXML element objects from parsed HTML (Nokogiri nodes).
+    # Builds OOXML element objects from parsed HTML (Moxml nodes).
     #
     # Pure functions — no state, no side effects.
     # Used by HtmlToOoxmlConverter to construct OOXML paragraphs, tables, runs.
@@ -11,7 +11,7 @@ module Uniword
     class HtmlElementBuilder
       # Build an OOXML Paragraph from an HTML element.
       #
-      # @param element [Nokogiri::XML::Element] HTML element
+      # @param element [Moxml::Element] HTML element
       # @return [Uniword::Wordprocessingml::Paragraph, nil]
       def self.build_paragraph(element)
         paragraph = Uniword::Wordprocessingml::Paragraph.new
@@ -32,11 +32,11 @@ module Uniword
       # cell insertion. The grid layout is computed row-by-row to correctly
       # place vMerge continuation cells where HTML rowspan omits cells.
       #
-      # @param html_table [Nokogiri::XML::Element] HTML table element
+      # @param html_table [Moxml::Element] HTML table element
       # @return [Uniword::Wordprocessingml::Table, nil]
       def self.build_table(html_table)
         table = Uniword::Wordprocessingml::Table.new
-        html_rows = html_table.css("tr")
+        html_rows = html_table.xpath(".//tr")
         return nil if html_rows.empty?
 
         # Track columns occupied by rowspan: col_idx → remaining continuation rows
@@ -47,7 +47,7 @@ module Uniword
           row = Uniword::Wordprocessingml::TableRow.new
           col_idx = 0
 
-          html_row.css("td, th").each do |html_cell|
+          html_row.xpath(".//td | .//th").each do |html_cell|
             # Insert vMerge continuation cells for columns occupied by rowspan
             while occupied.key?(col_idx)
               row.cells << create_vmerge_continuation_cell
@@ -60,13 +60,13 @@ module Uniword
             row.cells << cell
 
             # Track rowspan for continuation cell insertion in subsequent rows
-            rowspan = html_cell.attr("rowspan")&.to_i
+            rowspan = html_cell.attribute("rowspan")&.value&.to_i
             if rowspan && rowspan > 1
-              colspan = html_cell.attr("colspan")&.to_i || 1
+              colspan = html_cell.attribute("colspan")&.value&.to_i || 1
               colspan.times { |c| occupied[col_idx + c] = rowspan - 1 }
             end
 
-            col_idx += html_cell.attr("colspan")&.to_i || 1
+            col_idx += html_cell.attribute("colspan")&.value&.to_i || 1
           end
 
           # Handle remaining occupied columns at end of row
@@ -88,13 +88,13 @@ module Uniword
 
       # Build an OOXML TableRow from an HTML tr element.
       #
-      # @param html_row [Nokogiri::XML::Element] HTML tr element
+      # @param html_row [Moxml::Element] HTML tr element
       # @return [Uniword::Wordprocessingml::TableRow, nil]
       def self.build_row(html_row)
         row = Uniword::Wordprocessingml::TableRow.new
         cells = []
 
-        html_row.css("td, th").each do |html_cell|
+        html_row.xpath(".//td | .//th").each do |html_cell|
           cell = build_cell(html_cell)
           cells << cell if cell
         end
@@ -109,7 +109,7 @@ module Uniword
       #
       # Handles colspan → gridSpan, rowspan → vMerge restart, <th> → header.
       #
-      # @param html_cell [Nokogiri::XML::Element] HTML td/th element
+      # @param html_cell [Moxml::Element] HTML td/th element
       # @return [Uniword::Wordprocessingml::TableCell, nil]
       def self.build_cell(html_cell)
         cell = Uniword::Wordprocessingml::TableCell.new
@@ -118,8 +118,8 @@ module Uniword
         cell.header = html_cell.name.downcase == "th"
 
         # Handle colspan → gridSpan, rowspan → vMerge restart
-        colspan = html_cell.attr("colspan")
-        rowspan = html_cell.attr("rowspan")
+        colspan = html_cell.attribute("colspan")&.value
+        rowspan = html_cell.attribute("rowspan")&.value
 
         if (colspan && colspan.to_i > 1) || (rowspan && rowspan.to_i > 1)
           cell.properties ||= Uniword::Wordprocessingml::TableCellProperties.new
@@ -134,7 +134,9 @@ module Uniword
         end
 
         # Convert cell content to paragraphs
-        html_cell.css("p, div, h1, h2, h3, h4, h5, h6").each do |para_element|
+        block_tags = ".//p | .//div | .//h1 | .//h2 | .//h3 | .//h4 | " \
+                     ".//h5 | .//h6"
+        html_cell.xpath(block_tags).each do |para_element|
           paragraph = build_paragraph(para_element)
           cell.paragraphs << paragraph if paragraph
         end
@@ -165,7 +167,7 @@ module Uniword
 
       # Create an OOXML Run from an HTML element with inline formatting.
       #
-      # @param element [Nokogiri::XML::Element] HTML element
+      # @param element [Moxml::Element] HTML element
       # @return [Uniword::Wordprocessingml::Run, nil]
       def self.create_run_from_element(element)
         text = element.text.strip
@@ -182,7 +184,7 @@ module Uniword
 
       # Create an OOXML SDT from an HTML w:sdt element.
       #
-      # @param element [Nokogiri::XML::Element] HTML w:sdt element
+      # @param element [Moxml::Element] HTML w:sdt element
       # @return [Uniword::Wordprocessingml::StructuredDocumentTag, nil]
       def self.create_sdt_from_element(element)
         text = element.text.strip
@@ -213,7 +215,7 @@ module Uniword
 
       # Apply CSS class → OOXML style mapping.
       def self.apply_css_style(paragraph, element)
-        css_class = element.attr("class")
+        css_class = element.attribute("class")&.value
         return unless css_class && !css_class.empty?
 
         mapped_style = HtmlFormattingMapper.map_css_class_to_style(css_class)
@@ -230,13 +232,12 @@ module Uniword
       # → FootnoteReference run, <span class="MsoEndnoteReference"> → EndnoteReference run.
       def self.build_children(paragraph, element)
         element.children.each do |child|
-          case child.type
-          when Nokogiri::XML::Node::TEXT_NODE
+          if child.is_a?(Moxml::Text)
             text = child.text.strip
             next if text.empty?
 
             paragraph.runs << create_run(text)
-          when Nokogiri::XML::Node::ELEMENT_NODE
+          elsif child.is_a?(Moxml::Element)
             case child.name.downcase
             when "w:sdt", "sdt"
               sdt = create_sdt_from_element(child)
@@ -273,44 +274,53 @@ module Uniword
 
       # Parse SDT attributes from HTML element.
       def self.parse_sdt_attributes(element)
-        attrs = element.attributes
-        return nil if attrs.empty?
+        return nil if element.attributes.empty?
 
         sdt_props =
           Uniword::Wordprocessingml::StructuredDocumentTagProperties.new
 
-        if attrs["showingplchdr"] || attrs["ShowingPlcHdr"]
+        if attr_value(element, "showingplchdr") ||
+            attr_value(element, "ShowingPlcHdr")
           sdt_props.showing_placeholder_header =
             Uniword::Wordprocessingml::StructuredDocumentTag::ShowingPlaceholderHeader.new
         end
 
-        if attrs["temporary"] || attrs["Temporary"]
+        if attr_value(element, "temporary") ||
+            attr_value(element, "Temporary")
           sdt_props.temporary =
             Uniword::Wordprocessingml::StructuredDocumentTag::Temporary.new
         end
 
-        doc_part = attrs["docpart"] || attrs["DocPart"]
+        doc_part = attr_value(element, "docpart") ||
+          attr_value(element, "DocPart")
         if doc_part
           placeholder =
             Uniword::Wordprocessingml::StructuredDocumentTag::Placeholder.new
           doc_part_ref =
-            Uniword::Wordprocessingml::StructuredDocumentTag::DocPartReference.new(value: doc_part.value)
+            Uniword::Wordprocessingml::StructuredDocumentTag::DocPartReference.new(
+              value: doc_part,
+            )
           placeholder.doc_part = doc_part_ref
           sdt_props.placeholder = placeholder
         end
 
-        if attrs["text"] || attrs["Text"]
+        if attr_value(element, "text") || attr_value(element, "Text")
           sdt_props.text =
-            Uniword::Wordprocessingml::StructuredDocumentTag::Text.new(value: "whole")
+            Uniword::Wordprocessingml::StructuredDocumentTag::Text.new(
+              value: "whole",
+            )
         end
 
-        id_attr = attrs["id"] || attrs["ID"]
+        id_attr = attr_value(element, "id") || attr_value(element, "ID")
         if id_attr
           sdt_props.id =
-            Uniword::Wordprocessingml::StructuredDocumentTag::Id.new(value: id_attr.value.to_i)
+            Uniword::Wordprocessingml::StructuredDocumentTag::Id.new(
+              value: id_attr.to_i,
+            )
         end
 
-        if attrs["bibliography"] || attrs["Bibliography"]
+        if attr_value(element, "bibliography") ||
+            attr_value(element, "Bibliography")
           sdt_props.bibliography =
             Uniword::Wordprocessingml::StructuredDocumentTag::Bibliography.new
         end
@@ -318,15 +328,20 @@ module Uniword
         sdt_props
       end
 
+      # Read an attribute value from a Moxml element by name.
+      def self.attr_value(element, name)
+        element.attribute(name)&.value
+      end
+
       # Create a Run with Break from an HTML <br> element.
       #
-      # @param element [Nokogiri::XML::Element] <br> element
+      # @param element [Moxml::Element] <br> element
       # @return [Uniword::Wordprocessingml::Run]
       def self.create_break_run(element)
         run = Uniword::Wordprocessingml::Run.new
         brk = Uniword::Wordprocessingml::Break.new
-        style = element.attr("style").to_s
-        clear = element.attr("clear").to_s
+        style = element.attribute("style")&.value.to_s
+        clear = element.attribute("clear")&.value.to_s
         if style.include?("page-break-before") || style.include?("page-break-after") || clear == "all"
           brk.type = "page"
         end
@@ -336,27 +351,27 @@ module Uniword
 
       # Check if element is a footnote reference span.
       #
-      # @param element [Nokogiri::XML::Element]
+      # @param element [Moxml::Element]
       # @return [Boolean]
       def self.footnote_reference_span?(element)
         return false unless element.name.downcase == "span"
 
-        element.attr("class").to_s.split.include?("MsoFootnoteReference")
+        element.attribute("class")&.value.to_s.split.include?("MsoFootnoteReference")
       end
 
       # Check if element is an endnote reference span.
       #
-      # @param element [Nokogiri::XML::Element]
+      # @param element [Moxml::Element]
       # @return [Boolean]
       def self.endnote_reference_span?(element)
         return false unless element.name.downcase == "span"
 
-        element.attr("class").to_s.split.include?("MsoEndnoteReference")
+        element.attribute("class")&.value.to_s.split.include?("MsoEndnoteReference")
       end
 
       # Create a Run with FootnoteReference from an HTML footnote reference span.
       #
-      # @param element [Nokogiri::XML::Element] Span element with MsoFootnoteReference class
+      # @param element [Moxml::Element] Span with MsoFootnoteReference class
       # @return [Uniword::Wordprocessingml::Run]
       def self.create_footnote_reference_run(element)
         run = Uniword::Wordprocessingml::Run.new
@@ -368,7 +383,7 @@ module Uniword
 
       # Create a Run with EndnoteReference from an HTML endnote reference span.
       #
-      # @param element [Nokogiri::XML::Element] Span element with MsoEndnoteReference class
+      # @param element [Moxml::Element] Span with MsoEndnoteReference class
       # @return [Uniword::Wordprocessingml::Run]
       def self.create_endnote_reference_run(element)
         run = Uniword::Wordprocessingml::Run.new
@@ -382,13 +397,13 @@ module Uniword
       #
       # Tries: nested <a href="#_ftnN">, then text content digits.
       #
-      # @param element [Nokogiri::XML::Element]
+      # @param element [Moxml::Element]
       # @return [String, nil]
       def self.extract_note_id(element)
         # Try nested <a href="#_ftnN"> or <a href="#_ednN">
-        anchor = element.at_css("a[href^='#']")
+        anchor = element.at_xpath('.//a[starts-with(@href, "#")]')
         if anchor
-          href = anchor.attr("href").sub(/^#/, "")
+          href = anchor.attribute("href")&.value&.sub(/^#/, "")
           if href =~ /(\d+)\s*$/
             return Regexp.last_match(1)
           end
@@ -405,23 +420,22 @@ module Uniword
 
       # Create a Hyperlink from an HTML <a href> element.
       #
-      # @param element [Nokogiri::XML::Element] <a> element
+      # @param element [Moxml::Element] <a> element
       # @return [Uniword::Wordprocessingml::Hyperlink, nil]
       def self.create_hyperlink(element)
-        href = element.attr("href")
+        href = element.attribute("href")&.value
         return nil unless href
 
         hyperlink = Uniword::Wordprocessingml::Hyperlink.new
         hyperlink.target = href
 
         element.children.each do |child|
-          case child.type
-          when Nokogiri::XML::Node::TEXT_NODE
+          if child.is_a?(Moxml::Text)
             text = child.text.strip
             next if text.empty?
 
             hyperlink.runs << create_run(text)
-          when Nokogiri::XML::Node::ELEMENT_NODE
+          elsif child.is_a?(Moxml::Element)
             run = create_run_from_element(child)
             hyperlink.runs << run if run
           end

data/lib/uniword/transformation/html_formatting_mapper.rb

@@ -30,7 +30,7 @@ module Uniword
       #
       # Handles nested formatting like <u><em><strong>text</strong></em></u>.
       #
-      # @param element [Nokogiri::XML::Element] HTML element
+      # @param element [Moxml::Element] HTML element
       # @return [Uniword::Wordprocessingml::RunProperties]
       def self.collect_formatting(element)
         props = Uniword::Wordprocessingml::RunProperties.new
@@ -118,10 +118,10 @@ module Uniword
 
       # Apply formatting from span element's style attribute.
       #
-      # @param element [Nokogiri::XML::Element] span element
+      # @param element [Moxml::Element] span element
       # @param props [Uniword::Wordprocessingml::RunProperties]
       def self.apply_span_styles(element, props)
-        style = element.attr("style") || ""
+        style = element.attribute("style")&.value || ""
 
         if style =~ /color:\s*#?([0-9a-fA-F]{6})/i
           props.color =

data/lib/uniword/transformation/html_to_ooxml_converter.rb

@@ -18,15 +18,15 @@ module Uniword
         return [] if html_content.nil? || html_content.empty?
 
         body = HtmlFormattingMapper.extract_body(html_content)
-        doc = Nokogiri::HTML(body)
+        doc = Moxml.new.parse_html(body)
         paragraphs = []
 
-        doc.css("p, h1, h2, h3, h4, h5, h6, li, div, tr").each do |element|
-          next if element.ancestors("td, th").any?
+        doc.xpath(".//p | .//h1 | .//h2 | .//h3 | .//h4 | .//h5 | .//h6 | .//li | .//div | .//tr").each do |element|
+          next if element.ancestors("td").any? || element.ancestors("th").any?
           next if %w[tr td].include?(element.name)
 
           if %w[div li].include?(element.name) &&
-              element.css("p, h1, h2, h3, h4, h5, h6, li, div, tr").any?
+              element.xpath(".//p | .//h1 | .//h2 | .//h3 | .//h4 | .//h5 | .//h6 | .//li | .//div | .//tr").any?
             next
           end
 
@@ -45,10 +45,10 @@ module Uniword
         return [] if html_content.nil? || html_content.empty?
 
         body = HtmlFormattingMapper.extract_body(html_content)
-        doc = Nokogiri::HTML(body)
+        doc = Moxml.new.parse_html(body)
         tables = []
 
-        doc.css("table").each do |html_table|
+        doc.xpath(".//table").each do |html_table|
           table = HtmlElementBuilder.build_table(html_table)
           tables << table if table
         end
@@ -58,7 +58,7 @@ module Uniword
 
       # Convert a single HTML table to OOXML table.
       #
-      # @param html_table [Nokogiri::XML::Element] HTML table element
+      # @param html_table [Moxml::Element] HTML table element
       # @return [Uniword::Wordprocessingml::Table, nil]
       def self.html_table_to_table(html_table)
         HtmlElementBuilder.build_table(html_table)
@@ -66,7 +66,7 @@ module Uniword
 
       # Convert a single HTML row to OOXML table row.
       #
-      # @param html_row [Nokogiri::XML::Element] HTML tr element
+      # @param html_row [Moxml::Element] HTML tr element
       # @return [Uniword::Wordprocessingml::TableRow, nil]
       def self.html_row_to_row(html_row)
         HtmlElementBuilder.build_row(html_row)
@@ -74,7 +74,7 @@ module Uniword
 
       # Convert a single HTML cell to OOXML table cell.
       #
-      # @param html_cell [Nokogiri::XML::Element] HTML td/th element
+      # @param html_cell [Moxml::Element] HTML td/th element
       # @return [Uniword::Wordprocessingml::TableCell, nil]
       def self.html_cell_to_cell(html_cell)
         HtmlElementBuilder.build_cell(html_cell)
@@ -82,7 +82,7 @@ module Uniword
 
       # Convert a single HTML element to OOXML paragraph.
       #
-      # @param element [Nokogiri::XML::Element] HTML element
+      # @param element [Moxml::Element] HTML element
       # @return [Uniword::Wordprocessingml::Paragraph, nil]
       def self.html_element_to_paragraph(element)
         HtmlElementBuilder.build_paragraph(element)
@@ -98,7 +98,7 @@ module Uniword
 
       # Create a run from HTML element with inline formatting.
       #
-      # @param element [Nokogiri::XML::Element] HTML element
+      # @param element [Moxml::Element] HTML element
       # @return [Uniword::Wordprocessingml::Run, nil]
       def self.create_run_from_element(element)
         HtmlElementBuilder.create_run_from_element(element)

data/lib/uniword/transformation/mhtml_element_renderer.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require "nokogiri"
 
 module Uniword
   module Transformation
@@ -625,7 +624,7 @@ module Uniword
         return "" unless content
 
         xml = content.to_xml
-        doc = Nokogiri::HTML(xml)
+        doc = Moxml.new.parse_html(xml)
         doc.text.gsub(/\s+/, " ").strip
       end
 

data/lib/uniword/validation/schema_registry.rb

@@ -1,14 +1,14 @@
 # frozen_string_literal: true
 
 require "moxml"
-require "nokogiri"
+require "leptris/xml/xsd"
 
 module Uniword
   module Validation
     # Maps XML namespace URIs to XSD schema files and loads schemas for validation.
     #
     # Uses Moxml for namespace detection (parsing XML to find declared namespaces)
-    # and Nokogiri::XML::Schema for actual XSD validation.
+    # and Moxml::XSD (Leptris engine) for actual XSD validation.
     #
     # The registry knows which OOXML namespace URIs correspond to which XSD files
     # bundled in data/schemas/.
@@ -17,7 +17,7 @@ module Uniword
     #   registry = SchemaRegistry.new
     #   ns_uris = registry.detect_namespaces(xml_string)
     #   schema = registry.schema_for_namespaces(ns_uris)
-    #   errors = schema.validate(Nokogiri::XML(xml_string))
+    #   errors = schema.validate(xml_string)
     class SchemaRegistry
       # Map of namespace URI => XSD file (relative to data/schemas/)
       NAMESPACE_XSD_MAP = {
@@ -145,7 +145,7 @@ module Uniword
       # Load and cache an XSD schema for validation.
       #
       # @param xsd_relative_path [String] Path relative to schemas_dir
-      # @return [Nokogiri::XML::Schema] Compiled schema
+      # @return [Moxml::XSD::Schema] Compiled schema
       def load_schema(xsd_relative_path)
         return @schema_cache[xsd_relative_path] if @schema_cache.key?(xsd_relative_path)
 
@@ -155,18 +155,11 @@ module Uniword
                 "XSD schema not found: #{xsd_path}"
         end
 
-        # Nokogiri::XML::Schema resolves relative imports from CWD.
-        # We chdir to the schema file's own directory so imports like
-        # "word12.xsd" (from microsoft/wml-2010.xsd) resolve correctly.
-        schema = nil
-        original_dir = Dir.pwd
-        schema_dir = File.dirname(xsd_path)
-        begin
-          Dir.chdir(schema_dir)
-          schema = Nokogiri::XML::Schema(File.read(File.basename(xsd_path)))
-        ensure
-          Dir.chdir(original_dir)
-        end
+        # Path-based compilation resolves xsd:import chains relative
+        # to the schema file's own directory; string compilation does
+        # not resolve them.
+        handle = Leptris::XML::XSD.compile_file(xsd_path)
+        schema = Moxml::XSD::Schema.new(handle, @moxml)
 
         @schema_cache[xsd_relative_path] = schema
         schema