moxml 0.1.13 → 0.1.15

data/spec/moxml/allocation_guard_spec.rb

@@ -0,0 +1,282 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/allocation_helper"
+
+# Allocation guard specs — these run in CI by default (no :performance tag).
+#
+# These specs enforce allocation budgets per adapter per operation.
+# If an adapter exceeds its threshold, the spec fails with a diagnostic
+# message showing the actual vs expected allocation count.
+#
+# Thresholds are in AllocationHelper::THRESHOLDS and should be tightened
+# as optimizations are confirmed.
+RSpec.describe "Allocation guards", order: :defined do
+  def threshold_for(adapter_name, operation)
+    AllocationHelper.threshold(adapter_name, operation)
+  end
+
+  def guard_allocations(adapter_name, operation, &block)
+    allocs = AllocationHelper.count_allocations(&block)
+    limit = threshold_for(adapter_name, operation)
+
+    if allocs > limit
+      # Generate StackProf diagnostic on failure
+      profile = AllocationHelper.profile_allocations(&block)
+      raise(<<~MSG)
+        #{adapter_name}/#{operation}: #{allocs} allocations exceeds limit of #{limit}
+
+        #{profile}
+      MSG
+    end
+    allocs
+  end
+
+  shared_examples "allocation guard" do |adapter_name|
+    let(:ctx) { Moxml::Context.new(adapter_name) }
+
+    # ----------------------------------------------------------------
+    # Parse allocation guard
+    # ----------------------------------------------------------------
+    describe "parse allocations" do
+      it "parses 100-element document within allocation budget" do
+        xml = generate_xml(100)
+        allocs = guard_allocations(adapter_name, :parse_100) { ctx.parse(xml) }
+        expect(allocs).to be <= threshold_for(adapter_name, :parse_100)
+      end
+
+      it "parses 50-element document within allocation budget" do
+        xml = generate_xml(50)
+        allocs = guard_allocations(adapter_name, :parse_50) { ctx.parse(xml) }
+        expect(allocs).to be <= threshold_for(adapter_name, :parse_50)
+      end
+
+      it "parse + root.name is allocation-efficient" do
+        xml = generate_xml(100)
+        allocs = guard_allocations(adapter_name, :parse_and_root) do
+          doc = ctx.parse(xml)
+          doc.root.name
+        end
+        expect(allocs).to be <= threshold_for(adapter_name, :parse_and_root)
+      end
+    end
+
+    # ----------------------------------------------------------------
+    # Cache hit guards — second access should allocate near-zero objects
+    # ----------------------------------------------------------------
+    describe "cache hit guards" do
+      let(:simple_xml) { "<root><a/><b/><c/></root>" }
+      let(:attr_xml) { '<root x="1" y="2" z="3"><child k="4"/></root>' }
+
+      it "children access is cached after first call" do
+        doc = ctx.parse(simple_xml)
+        root = doc.root
+        # Warm the cache
+        root.children.to_a
+
+        allocs = AllocationHelper.count_allocations { root.children.to_a }
+        expect(allocs).to be <= threshold_for(adapter_name, :cached_children_access),
+                          "Second children access (#{allocs}) should allocate <= #{threshold_for(
+                            adapter_name, :cached_children_access
+                          )}"
+      end
+
+      it "attributes access is cached after first call" do
+        doc = ctx.parse(attr_xml)
+        root = doc.root
+        # Warm the cache
+        root.attributes
+
+        allocs = AllocationHelper.count_allocations { root.attributes }
+        expect(allocs).to be <= threshold_for(adapter_name, :cached_attributes_access),
+                          "Second attributes access (#{allocs}) should allocate <= #{threshold_for(
+                            adapter_name, :cached_attributes_access
+                          )}"
+      end
+
+      it "NodeSet iteration is cached on second pass" do
+        xml = generate_xml(20)
+        doc = ctx.parse(xml)
+        root = doc.root
+        # Warm the cache
+        root.children.each { |_| nil }
+
+        allocs = AllocationHelper.count_allocations do
+          root.children.each do |_|
+            nil
+          end
+        end
+        expect(allocs).to be <= threshold_for(adapter_name, :cached_iteration),
+                          "Second NodeSet iteration (#{allocs}) should allocate <= #{threshold_for(
+                            adapter_name, :cached_iteration
+                          )}"
+      end
+    end
+
+    # ----------------------------------------------------------------
+    # Round-trip allocation guard
+    # ----------------------------------------------------------------
+    describe "round-trip allocations" do
+      it "parse → serialize → parse stays within budget" do
+        xml = generate_xml(50)
+        allocs = guard_allocations(adapter_name, :round_trip) do
+          doc = ctx.parse(xml)
+          serialized = doc.to_xml
+          ctx.parse(serialized)
+        end
+        expect(allocs).to be <= threshold_for(adapter_name, :round_trip)
+      end
+    end
+
+    # ----------------------------------------------------------------
+    # Scalability guard — allocations grow linearly, not quadratically
+    # ----------------------------------------------------------------
+    describe "scalability" do
+      it "allocation growth is linear with document size" do
+        xml_100 = generate_xml(100)
+        xml_200 = generate_xml(200)
+
+        allocs_100 = AllocationHelper.count_allocations { ctx.parse(xml_100) }
+        allocs_200 = AllocationHelper.count_allocations { ctx.parse(xml_200) }
+
+        ratio = allocs_200.to_f / allocs_100
+        max_ratio = threshold_for(adapter_name, :scalability_ratio)
+
+        expect(ratio).to be <= max_ratio,
+                         "200-element parse (#{allocs_200}) vs 100-element (#{allocs_100}) = #{ratio.round(2)}x, " \
+                         "expected <= #{max_ratio}x (linear growth)"
+      end
+    end
+
+    # ----------------------------------------------------------------
+    # Cache invalidation guards — mutation breaks cache
+    # ----------------------------------------------------------------
+    describe "cache invalidation" do
+      it "adding a child invalidates children cache" do
+        xml = "<root><a/></root>"
+        doc = ctx.parse(xml)
+        root = doc.root
+        children_before = root.children
+
+        new_elem = ctx.parse("<b/>").root
+        root.add_child(new_elem)
+
+        children_after = root.children
+        expect(children_before).not_to equal(children_after),
+                                       "Children cache should be invalidated after add_child"
+        expect(children_after.size).to eq(2)
+      end
+
+      it "setting text invalidates children cache" do
+        xml = "<root><a/></root>"
+        doc = ctx.parse(xml)
+        root = doc.root
+        children_before = root.children
+
+        root.text = "replaced"
+
+        children_after = root.children
+        expect(children_before).not_to equal(children_after),
+                                       "Children cache should be invalidated after text="
+      end
+
+      it "setting attribute invalidates attributes cache" do
+        xml = '<root a="1"/>'
+        doc = ctx.parse(xml)
+        root = doc.root
+        attrs_before = root.attributes
+
+        root["b"] = "2"
+
+        attrs_after = root.attributes
+        expect(attrs_before).not_to equal(attrs_after),
+                                    "Attributes cache should be invalidated after []="
+        expect(attrs_after.size).to eq(2)
+      end
+
+      it "removing attribute invalidates attributes cache" do
+        xml = '<root a="1" b="2"/>'
+        doc = ctx.parse(xml)
+        root = doc.root
+        attrs_before = root.attributes
+
+        root.remove_attribute("a")
+
+        attrs_after = root.attributes
+        expect(attrs_before).not_to equal(attrs_after),
+                                    "Attributes cache should be invalidated after remove_attribute"
+        expect(attrs_after.size).to eq(1)
+      end
+
+      it "removing a child invalidates parent's children cache" do
+        xml = "<root><a/><b/></root>"
+        doc = ctx.parse(xml)
+        root = doc.root
+        children_before = root.children
+        child_a = root.children.first
+
+        child_a.remove
+
+        children_after = root.children
+        expect(children_before).not_to equal(children_after),
+                                       "Parent's children cache should be invalidated after child.remove"
+        expect(children_after.size).to eq(1)
+      end
+    end
+
+    # ----------------------------------------------------------------
+    # NodeSet wrap cache guards
+    # ----------------------------------------------------------------
+    describe "NodeSet wrap cache" do
+      it "returns the same wrapper for same index" do
+        doc = ctx.parse("<root><a/><b/><c/></root>")
+        children = doc.root.children
+
+        first_access = children[0]
+        second_access = children[0]
+        expect(first_access).to equal(second_access),
+                                "Same index should return identical wrapper object"
+      end
+
+      it "returns the same wrapper from each as from []" do
+        doc = ctx.parse("<root><a/><b/><c/></root>")
+        children = doc.root.children
+
+        from_each = nil
+        children.each { |c| from_each = c if c.name == "b" }
+        from_index = children[1]
+
+        expect(from_each).to equal(from_index),
+                             "Node from #each should be identical to same index from #[]"
+      end
+
+      it "preserves cache across multiple iterations" do
+        doc = ctx.parse("<root><a/><b/><c/></root>")
+        children = doc.root.children
+
+        pass1 = children.map(&:name)
+        pass2 = children.map(&:name)
+
+        expect(pass1).to eq(pass2)
+        # Also verify object identity between passes
+        pass1_nodes = children.to_a
+        pass2_nodes = children.to_a
+        pass1_nodes.each_with_index do |node, i|
+          expect(node).to equal(pass2_nodes[i]),
+                          "Node #{i} should be identical across iterations"
+        end
+      end
+    end
+  end
+
+  # Run guards for each adapter
+  AllocationHelper::GUARDED_ADAPTERS.each do |adapter_name|
+    describe "#{adapter_name} adapter" do
+      before(:all) do
+        skip("#{adapter_name} adapter not available") unless AllocationHelper.adapter_available?(adapter_name)
+      end
+
+      it_behaves_like "allocation guard", adapter_name
+    end
+  end
+end

data/spec/moxml/builder_spec.rb

@@ -5,6 +5,28 @@ require "spec_helper"
 RSpec.describe Moxml::Builder do
   let(:context) { Moxml.new }
 
+  describe "#document" do
+    it "exposes the underlying document via document accessor" do
+      builder = described_class.new(context)
+      expect(builder.document).to be_a(Moxml::Document)
+    end
+
+    it "exposes the underlying document via doc alias" do
+      builder = described_class.new(context)
+      expect(builder.doc).to be_a(Moxml::Document)
+      expect(builder.doc).to equal(builder.document)
+    end
+
+    it "returns the same document before and after build" do
+      builder = described_class.new(context)
+      doc_before = builder.document
+      builder.build do
+        element "root"
+      end
+      expect(builder.document).to equal(doc_before)
+    end
+  end
+
   describe "#build" do
     it "builds a document with DSL" do
       doc = described_class.new(context).build do

data/spec/moxml/config_spec.rb

@@ -17,8 +17,8 @@ RSpec.describe Moxml::Config do
       expect(config.entity_load_mode).to eq(:required)
     end
 
-    it "sets default namespace_uri_mode to :strict" do
-      expect(config.namespace_uri_mode).to eq(:strict)
+    it "sets default namespace_validation_mode to :strict" do
+      expect(config.namespace_validation_mode).to eq(:strict)
     end
   end
 
@@ -66,26 +66,26 @@ RSpec.describe Moxml::Config do
     end
   end
 
-  describe "#namespace_uri_mode=" do
+  describe "#namespace_validation_mode=" do
     it "accepts :strict" do
-      config.namespace_uri_mode = :strict
-      expect(config.namespace_uri_mode).to eq(:strict)
+      config.namespace_validation_mode = :strict
+      expect(config.namespace_validation_mode).to eq(:strict)
     end
 
     it "accepts :lenient" do
-      config.namespace_uri_mode = :lenient
-      expect(config.namespace_uri_mode).to eq(:lenient)
+      config.namespace_validation_mode = :lenient
+      expect(config.namespace_validation_mode).to eq(:lenient)
     end
 
     it "accepts string values" do
-      config.namespace_uri_mode = "lenient"
-      expect(config.namespace_uri_mode).to eq(:lenient)
+      config.namespace_validation_mode = "lenient"
+      expect(config.namespace_validation_mode).to eq(:lenient)
     end
 
     it "raises error for invalid mode" do
       expect do
-        config.namespace_uri_mode = :invalid
-      end.to raise_error(ArgumentError, /Invalid namespace_uri_mode/)
+        config.namespace_validation_mode = :invalid
+      end.to raise_error(ArgumentError, /Invalid namespace_validation_mode/)
     end
   end
 

data/spec/moxml/doctype_spec.rb

@@ -46,4 +46,45 @@ RSpec.describe Moxml::Doctype do
       expect(doctype.name).to eq("html")
     end
   end
+
+  describe "parsing" do
+    %i[nokogiri oga rexml ox].each do |adapter_name|
+      context "with #{adapter_name} adapter" do
+        let(:ctx) { Moxml.new(adapter_name) }
+
+        it "parses PUBLIC doctype with external and system identifiers" do
+          xml = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html/>'
+          doc = ctx.parse(xml)
+          doctype = doc.children.find { |c| c.is_a?(described_class) }
+
+          expect(doctype).not_to be_nil
+          expect(doctype.name).to eq("html")
+          expect(doctype.external_id).to eq("-//W3C//DTD XHTML 1.0 Strict//EN")
+          expect(doctype.system_id).to eq("http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd")
+        end
+
+        it "parses SYSTEM doctype with system identifier only" do
+          xml = '<!DOCTYPE config SYSTEM "config.dtd"><config/>'
+          doc = ctx.parse(xml)
+          doctype = doc.children.find { |c| c.is_a?(described_class) }
+
+          expect(doctype).not_to be_nil
+          expect(doctype.name).to eq("config")
+          expect(doctype.external_id).to be_nil
+          expect(doctype.system_id).to eq("config.dtd")
+        end
+
+        it "parses simple doctype without identifiers" do
+          xml = "<!DOCTYPE html><html/>"
+          doc = ctx.parse(xml)
+          doctype = doc.children.find { |c| c.is_a?(described_class) }
+
+          expect(doctype).not_to be_nil
+          expect(doctype.name).to eq("html")
+          expect(doctype.external_id).to be_nil
+          expect(doctype.system_id).to be_nil
+        end
+      end
+    end
+  end
 end

data/spec/moxml/lazy_parse_spec.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/allocation_helper"
+
+# Lazy parse correctness tests — these run in CI by default.
+# Verifies that lazy parse produces correct document structure
+# across all adapters without eager wrapper construction.
+RSpec.describe "Moxml lazy parse" do
+  let(:xml) do
+    "<root><child><nested>text</nested></child><sibling>more</sibling></root>"
+  end
+
+  shared_examples "lazy parse behavior" do |adapter_name|
+    let(:ctx) { Moxml::Context.new(adapter_name) }
+
+    describe "#parse" do
+      it "returns a Document without eagerly building wrapper tree" do
+        doc = ctx.parse(xml)
+        expect(doc).to be_a(Moxml::Document)
+        expect(doc.root).to be_a(Moxml::Element)
+        expect(doc.root.name).to eq("root")
+      end
+
+      it "provides correct children via lazy access" do
+        doc = ctx.parse(xml)
+        root = doc.root
+        children = root.children.to_a
+        expect(children.size).to eq(2)
+        expect(children[0]).to be_a(Moxml::Element)
+        expect(children[0].name).to eq("child")
+        expect(children[1].name).to eq("sibling")
+      end
+
+      it "provides correct nested children" do
+        doc = ctx.parse(xml)
+        nested = doc.root.children[0].children[0]
+        expect(nested.name).to eq("nested")
+        expect(nested.text).to eq("text")
+      end
+
+      it "preserves attributes" do
+        xml_with_attrs = '<root a="1" b="2"><child c="3"/></root>'
+        doc = ctx.parse(xml_with_attrs)
+        root = doc.root
+        attrs = root.attributes
+        expect(attrs.size).to eq(2)
+        expect(root["a"]).to eq("1")
+        expect(root["b"]).to eq("2")
+        expect(root.children[0]["c"]).to eq("3")
+      end
+
+      it "preserves text content" do
+        doc = ctx.parse("<root>hello world</root>")
+        expect(doc.root.text).to eq("hello world")
+      end
+
+      it "preserves mixed content" do
+        mixed_xml = "<root>before<child/>after</root>"
+        doc = ctx.parse(mixed_xml)
+        expect(doc.root.text).to eq("beforeafter")
+      end
+
+      it "handles comments" do
+        comment_xml = "<root><!-- a comment --><child/></root>"
+        doc = ctx.parse(comment_xml)
+        children = doc.root.children.to_a
+        comment = children.find(&:comment?)
+        expect(comment).not_to be_nil
+        expect(comment.content).to include("a comment")
+      end
+
+      it "handles processing instructions" do
+        pi_xml = "<?pi-target pi-content?><root/>"
+        doc = ctx.parse(pi_xml)
+        expect(doc.root.name).to eq("root")
+      end
+
+      it "handles namespace declarations" do
+        ns_xml = '<root xmlns:ns="http://example.com"><ns:child/></root>'
+        doc = ctx.parse(ns_xml)
+        root = doc.root
+        nss = root.namespaces
+        expect(nss.size).to be >= 1
+      end
+
+      it "round-trips through serialize" do
+        doc = ctx.parse(xml)
+        serialized = doc.to_xml
+        doc2 = ctx.parse(serialized)
+        expect(doc2.root.name).to eq("root")
+        expect(doc2.root.children.to_a.size).to eq(2)
+      end
+    end
+  end
+
+  # Run for all guarded adapters
+  AllocationHelper::GUARDED_ADAPTERS.each do |adapter_name|
+    describe "#{adapter_name} adapter" do
+      before(:all) do
+        skip("#{adapter_name} adapter not available") unless AllocationHelper.adapter_available?(adapter_name)
+      end
+
+      it_behaves_like "lazy parse behavior", adapter_name
+
+      # CDATA behavior differs between adapters
+      it "handles CDATA sections" do
+        ctx = Moxml::Context.new(adapter_name)
+        cdata_xml = "<root><![CDATA[<not xml>]]></root>"
+        doc = ctx.parse(cdata_xml)
+        expect(doc.root).not_to be_nil
+      end
+    end
+  end
+end

data/spec/moxml/namespace_uri_validation_spec.rb

@@ -92,10 +92,10 @@ RSpec.describe "Namespace URI validation" do
     end
   end
 
-  describe "lenient namespace_uri_mode" do
+  describe "lenient namespace_validation_mode" do
     let(:context) do
       Moxml.new do |config|
-        config.namespace_uri_mode = :lenient
+        config.namespace_validation_mode = :lenient
       end
     end
 
@@ -134,7 +134,15 @@ RSpec.describe "Namespace URI validation" do
     end
 
     it "still accepts valid URIs" do
-      expect { element.add_namespace("ns", "http://example.com") }.not_to raise_error
+      expect do
+        element.add_namespace("ns", "http://example.com")
+      end.not_to raise_error
+    end
+
+    it "accepts prefixes with dots in lenient mode" do
+      expect do
+        element.add_namespace("xmlns_1.0", "http://example.com")
+      end.not_to raise_error
     end
   end
 end

data/spec/moxml/node_cache_spec.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/allocation_helper"
+
+# Node caching correctness tests — these run in CI by default.
+# Verifies that cache semantics (identity, invalidation) work correctly
+# across all adapters.
+RSpec.describe "Moxml node caching" do
+  shared_examples "cached children" do |adapter_name|
+    let(:ctx) { Moxml::Context.new(adapter_name) }
+    let(:xml) { "<root><a/><b/><c/></root>" }
+    let(:doc) { ctx.parse(xml) }
+    let(:root) { doc.root }
+
+    describe "Node#children caching" do
+      it "returns the same NodeSet object on repeated calls" do
+        children1 = root.children
+        children2 = root.children
+        expect(children1).to equal(children2)
+      end
+
+      it "returns consistent child elements across calls" do
+        children1 = root.children.to_a
+        children2 = root.children.to_a
+        expect(children1.map(&:name)).to eq(children2.map(&:name))
+      end
+
+      it "invalidates cache when a child is added" do
+        children_before = root.children
+        root.add_child(ctx.parse("<d/>").root)
+        children_after = root.children
+        expect(children_before).not_to equal(children_after)
+        expect(children_after.to_a.size).to eq(4)
+      end
+
+      it "invalidates cache when text is set" do
+        children_before = root.children
+        root.text = "new text"
+        children_after = root.children
+        expect(children_before).not_to equal(children_after)
+      end
+    end
+
+    describe "Element#attributes caching" do
+      let(:attr_xml) { '<root a="1" b="2"><child c="3"/></root>' }
+      let(:attr_doc) { ctx.parse(attr_xml) }
+      let(:attr_root) { attr_doc.root }
+
+      it "returns the same array on repeated calls" do
+        attrs1 = attr_root.attributes
+        attrs2 = attr_root.attributes
+        expect(attrs1).to equal(attrs2)
+      end
+
+      it "returns consistent attribute values" do
+        attrs = attr_root.attributes
+        expect(attrs.to_h do |a|
+          [a.name, a.value]
+        end).to eq({ "a" => "1", "b" => "2" })
+      end
+
+      it "invalidates cache when an attribute is set" do
+        attrs_before = attr_root.attributes
+        attr_root["c"] = "3"
+        attrs_after = attr_root.attributes
+        expect(attrs_before).not_to equal(attrs_after)
+        expect(attrs_after.size).to eq(3)
+      end
+
+      it "invalidates cache when an attribute is removed" do
+        attrs_before = attr_root.attributes
+        attr_root.remove_attribute("a")
+        attrs_after = attr_root.attributes
+        expect(attrs_before).not_to equal(attrs_after)
+        expect(attrs_after.size).to eq(1)
+      end
+    end
+
+    describe "Element#namespaces caching" do
+      let(:ns_xml) { '<root xmlns:a="http://a.com" xmlns:b="http://b.com"><a:child/></root>' }
+      let(:ns_doc) { ctx.parse(ns_xml) }
+      let(:ns_root) { ns_doc.root }
+
+      it "returns the same array on repeated calls" do
+        nss1 = ns_root.namespaces
+        nss2 = ns_root.namespaces
+        expect(nss1).to equal(nss2)
+      end
+
+      it "invalidates cache when a namespace is added" do
+        nss_before = ns_root.namespaces
+        ns_root.add_namespace("c", "http://c.com")
+        nss_after = ns_root.namespaces
+        expect(nss_before).not_to equal(nss_after)
+        expect(nss_after.size).to eq(3)
+      end
+    end
+  end
+
+  AllocationHelper::GUARDED_ADAPTERS.each do |adapter_name|
+    describe "#{adapter_name} adapter" do
+      before(:all) do
+        skip("#{adapter_name} adapter not available") unless AllocationHelper.adapter_available?(adapter_name)
+      end
+
+      it_behaves_like "cached children", adapter_name
+    end
+  end
+end