moxml 0.1.14 → 0.1.16

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
@@ -30,4 +52,238 @@ RSpec.describe Moxml::Builder do
       expect(doc.root.children.length).to eq(2)
     end
   end
+
+  describe "#element with no arguments" do
+    it "raises ArgumentError" do
+      builder = described_class.new(context)
+      expect do
+        builder.build { element }
+      end.to raise_error(ArgumentError, "element requires a tag name")
+    end
+  end
+
+  describe "#element with Hash (tag name collision)" do
+    it "creates an <element> tag when called with a Hash" do
+      doc = described_class.new(context).build do
+        element(name: "foo", type: "bar")
+      end
+
+      el = doc.root
+      expect(el.name).to eq("element")
+      expect(el["name"]).to eq("foo")
+      expect(el["type"]).to eq("bar")
+    end
+  end
+
+  describe "method_missing DSL" do
+    it "creates elements via bare method calls inside build block" do
+      doc = described_class.new(context).build do
+        root do
+          title("Hello")
+        end
+      end
+
+      expect(doc.root.name).to eq("root")
+      expect(doc.root.children.first.name).to eq("title")
+      expect(doc.root.children.first.text).to eq("Hello")
+    end
+
+    it "creates elements via explicit receiver" do
+      builder = described_class.new(context)
+      doc = builder.build do
+        element "root" do
+          builder.title("Hello")
+        end
+      end
+
+      title_el = doc.root.children.first
+      expect(title_el.name).to eq("title")
+      expect(title_el.text).to eq("Hello")
+    end
+
+    it "creates elements with attributes" do
+      builder = described_class.new(context)
+      doc = builder.build do
+        element "root" do
+          builder.item(id: "1", class: "active")
+        end
+      end
+
+      item_el = doc.root.children.first
+      expect(item_el.name).to eq("item")
+      expect(item_el["id"]).to eq("1")
+      expect(item_el["class"]).to eq("active")
+    end
+
+    it "creates elements with both text content and attributes" do
+      builder = described_class.new(context)
+      doc = builder.build do
+        element "root" do
+          builder.title("Hello", lang: "en")
+        end
+      end
+
+      title_el = doc.root.children.first
+      expect(title_el.name).to eq("title")
+      expect(title_el.text).to eq("Hello")
+      expect(title_el["lang"]).to eq("en")
+    end
+
+    it "creates nested elements with blocks" do
+      builder = described_class.new(context)
+      doc = builder.build do
+        element "root" do
+          builder.parent do
+            builder.child("text")
+          end
+        end
+      end
+
+      parent_el = doc.root.children.first
+      expect(parent_el.name).to eq("parent")
+      child_el = parent_el.children.first
+      expect(child_el.name).to eq("child")
+      expect(child_el.text).to eq("text")
+    end
+
+    it "creates elements with namespace attributes" do
+      builder = described_class.new(context)
+      doc = builder.build do
+        element "root" do
+          builder.schema(xmlns: "http://www.w3.org/2001/XMLSchema")
+        end
+      end
+
+      schema_el = doc.root.children.first
+      expect(schema_el.name).to eq("schema")
+    end
+  end
+
+  describe "trailing underscore stripping (special tags)" do
+    it "strips trailing underscore to allow reserved method names as tags" do
+      builder = described_class.new(context)
+      doc = builder.build do
+        element "root" do
+          builder.type_("Object")
+          builder.class_("String")
+          builder.id_("42")
+        end
+      end
+
+      children = doc.root.children
+      expect(children[0].name).to eq("type")
+      expect(children[0].text).to eq("Object")
+      expect(children[1].name).to eq("class")
+      expect(children[1].text).to eq("String")
+      expect(children[2].name).to eq("id")
+      expect(children[2].text).to eq("42")
+    end
+
+    it "strips trailing underscore with attributes" do
+      builder = described_class.new(context)
+      doc = builder.build do
+        element "root" do
+          builder.type_(name: "foo")
+        end
+      end
+
+      el = doc.root.children.first
+      expect(el.name).to eq("type")
+      expect(el["name"]).to eq("foo")
+    end
+
+    it "strips trailing underscore with block" do
+      builder = described_class.new(context)
+      doc = builder.build do
+        element "root" do
+          builder.class_ do
+            builder.name_("MyClass")
+          end
+        end
+      end
+
+      class_el = doc.root.children.first
+      expect(class_el.name).to eq("class")
+      expect(class_el.children.first.name).to eq("name")
+    end
+
+    it "works with bare method calls inside build block" do
+      doc = described_class.new(context).build do
+        root do
+          type_("Object")
+        end
+      end
+
+      expect(doc.root.children.first.name).to eq("type")
+      expect(doc.root.children.first.text).to eq("Object")
+    end
+
+    it "does not strip underscore from middle of name" do
+      builder = described_class.new(context)
+      doc = builder.build do
+        element "root" do
+          builder.my_element("text")
+        end
+      end
+
+      expect(doc.root.children.first.name).to eq("my_element")
+    end
+  end
+
+  describe "respond_to_missing?" do
+    it "returns true for arbitrary element names" do
+      builder = described_class.new(context)
+      expect(builder.respond_to?(:schema)).to be true
+      expect(builder.respond_to?(:custom_element)).to be true
+    end
+
+    it "returns false for reserved Ruby conversion and protocol methods" do
+      builder = described_class.new(context)
+      expect(builder.respond_to?(:to_ary)).to be false
+      expect(builder.respond_to?(:to_hash)).to be false
+      expect(builder.respond_to?(:to_str)).to be false
+      expect(builder.respond_to?(:to_xml)).to be false
+    end
+  end
+
+  describe "method_missing argument validation" do
+    it "raises ArgumentError for unexpected extra arguments" do
+      builder = described_class.new(context)
+      expect do
+        builder.build do
+          element "root" do
+            builder.foo("text", { id: "1" }, "extra")
+          end
+        end
+      end.to raise_error(ArgumentError, /unexpected arguments for foo/)
+    end
+
+    it "raises ArgumentError when combining text content with a block" do
+      builder = described_class.new(context)
+      expect do
+        builder.build do
+          element "root" do
+            builder.title("Hello") { builder.child }
+          end
+        end
+      end.to raise_error(ArgumentError, /title: cannot combine text content with a block/)
+    end
+  end
+
+  describe "@current restoration on error" do
+    it "restores @current when block raises" do
+      builder = described_class.new(context)
+      expect do
+        builder.build do
+          element "root" do
+            element "child" do
+              raise "test error"
+            end
+          end
+        end
+      end.to raise_error(RuntimeError, "test error")
+
+      expect(builder.instance_variable_get(:@current)).to equal(builder.document)
+    end
+  end
 end

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