moxml 0.1.17 → 0.1.18

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bbd69145e9a360635af848bf0bdda2883e35760b2763021f6bf6f1d6dca9827e
-  data.tar.gz: aa492e21514fd80a01f98709eddf8c3aa323b584210d56534ad5e2c2b467df18
+  metadata.gz: c1daf227e9effc582c66e780516135481aa48e467226a4267974633a4673f786
+  data.tar.gz: 5b230e79a208eb4b1c5e32175df364e5b42f9e766c4c8189eb18fcad09bb79bf
 SHA512:
-  metadata.gz: 1cdb7d6c934f1ea788a40d81d987c97d4c1fc21ad71d22eaac73abf45d093680667f3303b35934378b8cce0d99e3fc9db47c85632678247426527d7fb3491bed
-  data.tar.gz: 79c352eb8df9b86831d554e17538abd4da8a6dfce61b4e566bc236334601e43bff7c670894ea05c72abac40bb1b3b90375ef8caaf6b488a9c43bc33fc70d6785
+  metadata.gz: e39941f6f51567655c246f1e8d6225c6ab572c68958fd9ca4a74ca191af4493e1bf74ff0feed84792cc87e5681cce1d8ae291533e992d07b70fdfb1063d96a67
+  data.tar.gz: 41ca4a3954bf2e713703124758309e5d1e056d44826cdacf3b4693c5bf37c463579462a6c0ecb3aa65e4c3cafaeef1e2ad0d8a5af9ebe2e1b9f4a695e7678ff4

data/lib/moxml/adapter/libxml.rb

@@ -294,9 +294,6 @@ module Moxml
           result = []
           if native_node.children?
             native_node.each_child do |child|
-              # Skip whitespace-only text nodes
-              next if child.text? && child.content.to_s.strip.empty?
-
               result << patch_node(child)
             end
           end

data/lib/moxml/adapter/nokogiri.rb

@@ -182,11 +182,7 @@ module Moxml
         end
 
         def children(node)
-          node.children.reject do |child|
-            child.text? && child.content.strip.empty? &&
-              !(child.previous_sibling.nil? && child.next_sibling.nil?) &&
-              !adjacent_to_entity_reference?(child)
-          end
+          node.children
         end
 
         def adjacent_to_entity_reference?(node)

data/lib/moxml/adapter/oga.rb

@@ -193,12 +193,18 @@ module Moxml
 
           return all_children unless node.is_a?(::Oga::XML::Node) || node.is_a?(::Oga::XML::Document)
 
-          all_children + node.children.reject do |child|
-            child.is_a?(::Oga::XML::Text) &&
-              child.text.strip.empty? &&
-              !(child.previous.nil? && child.next.nil?) &&
-              !adjacent_to_entity_reference?(child)
+          child_nodes = node.children.to_a
+          # Filter out whitespace-only text nodes at document level only.
+          # Document-level whitespace (between <?xml?> and <root>) is
+          # formatting, not content, and differs across adapters.
+          # Whitespace inside elements (e.g. "FigureA.1" spacing) is
+          # meaningful and must be preserved.
+          if node.is_a?(::Oga::XML::Document)
+            child_nodes = child_nodes.reject do |child|
+              child.is_a?(::Oga::XML::Text) && child.text.strip.empty?
+            end
           end
+          all_children + child_nodes
         end
 
         def adjacent_to_entity_reference?(node)

data/lib/moxml/adapter/rexml.rb

@@ -177,12 +177,8 @@ module Moxml
         def children(node)
           return [] unless node.is_a?(::REXML::Parent)
 
-          # Get all children and filter out empty text nodes between elements
-          result = node.children.reject do |child|
-            child.is_a?(::REXML::Text) &&
-              child.to_s.strip.empty? &&
-              !(child.next_sibling.nil? && child.previous_sibling.nil?)
-          end
+          # Return all children preserving whitespace text nodes
+          result = node.children.dup
 
           # Include any EntityReference wrappers stored alongside native children
           entity_refs = attachments.get(node, :entity_refs)

data/lib/moxml/config.rb

@@ -3,7 +3,8 @@
 module Moxml
   class Config
     VALID_ADAPTERS = %i[nokogiri oga rexml ox headed_ox libxml].freeze
-    DEFAULT_ADAPTER = VALID_ADAPTERS.first
+    DEFAULT_ADAPTER = :nokogiri
+    OPAL_DEFAULT_ADAPTER = :oga
 
     # Entity loading modes:
     # - :required - Must load entities, raise error if unavailable (default)
@@ -20,7 +21,21 @@ module Moxml
       end
 
       def default_adapter
-        @default_adapter ||= DEFAULT_ADAPTER
+        @default_adapter ||= runtime_default_adapter
+      end
+
+      def runtime_default_adapter
+        return OPAL_DEFAULT_ADAPTER if RUBY_ENGINE == "opal"
+
+        detect_loaded_adapter || DEFAULT_ADAPTER
+      end
+
+      def detect_loaded_adapter
+        return :nokogiri if Object.const_defined?(:Nokogiri)
+        return :ox if Object.const_defined?(:Ox)
+        return :oga if Object.const_defined?(:Oga)
+
+        nil
       end
     end
 

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.1.17"
+  VERSION = "0.1.18"
 end

data/spec/integration/shared_examples/edge_cases.rb

@@ -167,6 +167,91 @@ RSpec.shared_examples "Moxml Edge Cases" do
     end
   end
 
+  describe "whitespace text node preservation" do
+    # Ox/HeadedOx do not generate whitespace-only text nodes in their parser,
+    # so these tests only apply to adapters that do (Nokogiri, OGA, REXML, LibXML)
+    let(:preserves_ws) { !%i[ox headed_ox].include?(context.config.adapter_name) }
+
+    it "preserves whitespace-only text nodes between sibling elements" do
+      unless preserves_ws
+        skip "Ox/HeadedOx parser does not generate whitespace-only text nodes"
+      end
+
+      xml = <<~XML
+        <root>
+          <a>1</a>
+          <b>2</b>
+          <c>3</c>
+        </root>
+      XML
+
+      doc = context.parse(xml)
+      children = doc.root.children
+
+      # Should have whitespace text nodes between elements
+      expect(children.size).to be > 3
+
+      # Whitespace text nodes should be Text nodes
+      ws_nodes = children.select { |c| c.is_a?(Moxml::Text) && c.content.strip.empty? }
+      expect(ws_nodes).not_to be_empty
+
+      # Element children should still be accessible
+      elements = children.select { |c| c.is_a?(Moxml::Element) }
+      expect(elements.map(&:name)).to eq(%w[a b c])
+    end
+
+    it "preserves inline whitespace text nodes between text and elements" do
+      xml = "<p>Figure <sub>A</sub>.1</p>"
+      doc = context.parse(xml)
+
+      children = doc.root.children
+      expect(children.size).to eq(3)
+
+      # First child: "Figure " text node
+      expect(children[0]).to be_a(Moxml::Text)
+      expect(children[0].content).to eq("Figure ")
+
+      # Second child: <sub> element
+      expect(children[1]).to be_a(Moxml::Element)
+      expect(children[1].name).to eq("sub")
+      expect(children[1].text).to eq("A")
+
+      # Third child: ".1" text node
+      expect(children[2]).to be_a(Moxml::Text)
+      expect(children[2].content).to eq(".1")
+    end
+
+    it "preserves space-only text node as meaningful content" do
+      xml = "<p>Hello <b>world</b>!</p>"
+      doc = context.parse(xml)
+
+      children = doc.root.children
+      expect(children.size).to eq(3)
+
+      expect(children[0].content).to eq("Hello ")
+      expect(children[1]).to be_a(Moxml::Element)
+      expect(children[2].content).to eq("!")
+    end
+
+    it "distinguishes whitespace text nodes from element children" do
+      unless preserves_ws
+        skip "Ox/HeadedOx parser does not generate whitespace-only text nodes"
+      end
+
+      xml = "<root>  <child/>  </root>"
+      doc = context.parse(xml)
+
+      children = doc.root.children
+      # "  " before child, "  " after child
+      expect(children.size).to eq(3)
+      expect(children[0]).to be_a(Moxml::Text)
+      expect(children[0].content).to eq("  ")
+      expect(children[1]).to be_a(Moxml::Element)
+      expect(children[2]).to be_a(Moxml::Text)
+      expect(children[2].content).to eq("  ")
+    end
+  end
+
   describe "document structure edge cases" do
     it "handles deeply nested elements" do
       doc = context.create_document

data/spec/integration/shared_examples/entity_reference_whitespace.rb

@@ -104,7 +104,7 @@ RSpec.shared_examples "Entity Reference Whitespace Preservation" do
   end
 
   describe "structural whitespace filtering" do
-    it "still filters whitespace between elements" do
+    it "preserves whitespace text nodes between elements" do
       xml = <<~XML
         <root>
           <child1/>
@@ -115,8 +115,10 @@ RSpec.shared_examples "Entity Reference Whitespace Preservation" do
       doc = context.parse(xml)
       children = doc.root.children
 
-      expect(children.length).to eq(2)
-      expect(children.all?(Moxml::Element)).to be true
+      # Whitespace text nodes between elements are preserved
+      elements = children.select { |c| c.is_a?(Moxml::Element) }
+      expect(elements.length).to eq(2)
+      expect(elements.map(&:name)).to eq(%w[child1 child2])
     end
   end
 end

data/spec/integration/shared_examples/high_level/document_builder_behavior.rb

@@ -32,12 +32,14 @@ RSpec.shared_examples "Moxml::DocumentBuilder" do
 
       expect(doc.root.namespaces.count).to eq(1)
       expect(doc.root.namespaces.first.uri).to eq("http://example.org")
-      expect(doc.root.children[0]).to be_a(Moxml::Comment)
-      expect(doc.root.children[1]).to be_a(Moxml::Element)
-      expect(doc.root.children[1].name).to eq("child")
-      expect(doc.root.children[1]["id"]).to eq("1")
-      expect(doc.root.children[1].children.first).to be_a(Moxml::Cdata)
-      expect(doc.root.children[2]).to be_a(Moxml::ProcessingInstruction)
+      # Whitespace text nodes are preserved between elements
+      non_ws_children = doc.root.children.reject { |c| c.is_a?(Moxml::Text) && c.content.strip.empty? }
+      expect(non_ws_children[0]).to be_a(Moxml::Comment)
+      expect(non_ws_children[1]).to be_a(Moxml::Element)
+      expect(non_ws_children[1].name).to eq("child")
+      expect(non_ws_children[1]["id"]).to eq("1")
+      expect(non_ws_children[1].children.find { |c| c.is_a?(Moxml::Cdata) }).to be_a(Moxml::Cdata)
+      expect(non_ws_children[2]).to be_a(Moxml::ProcessingInstruction)
     end
   end
 end

data/spec/integration/shared_examples/integration_workflows.rb

@@ -113,7 +113,7 @@ RSpec.shared_examples "Moxml Integration" do
       expect(attr).to eq("value")
 
       # Test namespace override
-      deeper = a_element.children.first
+      deeper = a_element.children.find { |c| c.is_a?(Moxml::Element) }
       expect(deeper.namespace.uri).to eq("http://other.org")
     end
   end

data/spec/integration/shared_examples/node_wrappers/node_set_behavior.rb

@@ -41,7 +41,9 @@ RSpec.shared_examples "Moxml::NodeSet" do
       end
 
       it "compares nodes" do
-        expect(doc.xpath("//child")).to eq(doc.root.children)
+        xpath_results = doc.xpath("//child")
+        element_children = doc.root.children.select { |c| c.is_a?(Moxml::Element) }
+        expect(xpath_results.map(&:native)).to eq(element_children.map(&:native))
       end
     end
 

data/spec/moxml/moxml_spec.rb

@@ -2,6 +2,28 @@
 
 # spec/moxml_spec.rb
 RSpec.describe Moxml do
+  around do |example|
+    original_default = Moxml::Config.instance_variable_get(:@default)
+    original_default_adapter = Moxml::Config.instance_variable_get(:@default_adapter)
+
+    Moxml::Config.remove_instance_variable(:@default) if Moxml::Config.instance_variable_defined?(:@default)
+    Moxml::Config.remove_instance_variable(:@default_adapter) if Moxml::Config.instance_variable_defined?(:@default_adapter)
+
+    example.run
+  ensure
+    if original_default.nil?
+      Moxml::Config.remove_instance_variable(:@default) if Moxml::Config.instance_variable_defined?(:@default)
+    else
+      Moxml::Config.instance_variable_set(:@default, original_default)
+    end
+
+    if original_default_adapter.nil?
+      Moxml::Config.remove_instance_variable(:@default_adapter) if Moxml::Config.instance_variable_defined?(:@default_adapter)
+    else
+      Moxml::Config.instance_variable_set(:@default_adapter, original_default_adapter)
+    end
+  end
+
   it "has a version number" do
     expect(Moxml::VERSION).not_to be_nil
   end
@@ -34,6 +56,23 @@ RSpec.describe Moxml do
       expect(context.config.adapter_name).to eq(:nokogiri)
     end
 
+    it "defaults to oga on Opal" do
+      stub_const("RUBY_ENGINE", "opal")
+
+      context = described_class.new
+      expect(context.config.adapter_name).to eq(:oga)
+    end
+
+    it "prefers ox when it is already loaded" do
+      allow(Object).to receive(:const_defined?).and_call_original
+      allow(Object).to receive(:const_defined?).with(:Nokogiri).and_return(false)
+      allow(Object).to receive(:const_defined?).with(:Ox).and_return(true)
+      allow(Object).to receive(:const_defined?).with(:Oga).and_return(false)
+
+      context = described_class.new
+      expect(context.config.adapter_name).to eq(:ox)
+    end
+
     it "uses configured options from the block" do
       described_class.configure do |config|
         config.default_adapter = :oga

data/spec/performance/benchmark_spec.rb

@@ -27,7 +27,7 @@ RSpec.shared_examples "Performance Examples" do
         {
           nokogiri: { parser: 15, serializer: 1000 },
           oga: { parser: 10, serializer: 100 },
-          rexml: { parser: 0, serializer: 60 },
+          rexml: { parser: 0, serializer: 5 },
           ox: { parser: 2, serializer: 1000 },
           headed_ox: { parser: 2, serializer: 1000 },
           libxml: { parser: 10, serializer: 30 },

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.1.17
+  version: 0.1.18
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-04-24 00:00:00.000000000 Z
+date: 2026-04-27 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API