moxml 0.1.13 → 0.1.15

data/lib/moxml/document_builder.rb

@@ -13,15 +13,13 @@ module Moxml
       @current_doc = context.create_document(native_doc)
 
       # Transfer has_declaration flag if present
-      if native_doc.respond_to?(:instance_variable_get) &&
-          native_doc.instance_variable_defined?(:@moxml_has_declaration)
+      if native_doc.instance_variable_defined?(:@moxml_has_declaration)
         has_declaration = native_doc.instance_variable_get(:@moxml_has_declaration)
         @current_doc.has_xml_declaration = has_declaration
       end
 
       # Transfer DOCTYPE from parsed document if it exists
-      if native_doc.respond_to?(:instance_variable_get) &&
-          native_doc.instance_variable_defined?(:@moxml_doctype)
+      if native_doc.instance_variable_defined?(:@moxml_doctype)
         doctype = native_doc.instance_variable_get(:@moxml_doctype)
         if doctype
           @current_doc.native.instance_variable_set(:@moxml_doctype,
@@ -70,43 +68,54 @@ module Moxml
       content = adapter.text_content(node)
 
       # Check if we should restore entity references for this text
-      if context.config.restore_entities && content.to_s =~ /[<>&"']/
+      if context.config.restore_entities && text_has_restorable_entities?(content)
         restore_entities_in_text(content)
       else
         @node_stack.last&.add_child(Text.new(prepared, context))
       end
     end
 
+    def text_has_restorable_entities?(content)
+      return false unless content
+
+      registry = context.entity_registry
+      codepoints = registry.restorable_codepoints
+      content.each_char do |char|
+        return true if codepoints.include?(char.ord)
+      end
+      false
+    end
+
     def restore_entities_in_text(content)
       parent = @node_stack.last
       return unless parent
 
-      # Characters that should potentially be entity-encoded
-      # Per W3C XML spec, these characters have special meaning
-      entity_chars = {
-        "<" => "lt",
-        ">" => "gt",
-        "&" => "amp",
-        '"' => "quot",
-        "'" => "apos",
-      }
-
-      # Process character by character
-      chars = content.to_s.chars
-      chars.each do |char|
-        codepoint = char.ord
-        entity_name = context.entity_registry.primary_name_for_codepoint(codepoint)
+      registry = context.entity_registry
+      config = context.config
+      buffer = +""
 
-        if entity_name && entity_chars.value?(entity_name)
-          # This character should be an entity reference
-          entity_node = adapter.create_entity_reference(entity_name)
-          parent.add_child(EntityReference.new(entity_node, context))
+      content.to_s.each_char do |char|
+        codepoint = char.ord
+        name = registry.primary_name_for_codepoint(codepoint)
+
+        if name && registry.should_restore?(codepoint, config: config)
+          # Flush buffered text before the entity
+          unless buffer.empty?
+            parent.add_child(Text.new(adapter.create_text(buffer), context))
+            buffer.clear
+          end
+          parent.add_child(
+            EntityReference.new(adapter.create_entity_reference(name), context),
+          )
         else
-          # Regular character
-          text_node = adapter.create_text(char)
-          parent.add_child(Text.new(text_node, context))
+          buffer << char
         end
       end
+
+      # Flush remaining buffer
+      unless buffer.empty?
+        parent.add_child(Text.new(adapter.create_text(buffer), context))
+      end
     end
 
     def visit_cdata(node)
@@ -135,10 +144,7 @@ module Moxml
     end
 
     def visit_children(node)
-      node_children = children(node).dup
-      node_children.each do |child|
-        visit_node(child)
-      end
+      children(node).each { |child| visit_node(child) }
     end
 
     def node_type(node)

data/lib/moxml/element.rb

@@ -42,6 +42,7 @@ module Moxml
 
     def []=(name, value)
       adapter.set_attribute(@native, name, normalize_xml_value(value))
+      @attributes_cache = nil
     end
 
     def [](name)
@@ -64,19 +65,23 @@ module Moxml
     end
 
     def attributes
-      adapter.attributes(@native).map do |attr|
-        Attribute.new(attr, context)
+      @attributes ||= adapter.attributes(@native).map do |attr|
+        a = Attribute.new(attr, context)
+        a.instance_variable_set(:@parent_node, self)
+        a
       end
     end
 
     def remove_attribute(name)
       adapter.remove_attribute(@native, name)
+      @attributes_cache = nil
       self
     end
 
     def add_namespace(prefix, uri)
       adapter.create_namespace(@native, prefix, uri,
-                               namespace_uri_mode: context.config.namespace_uri_mode)
+                               namespace_validation_mode: context.config.namespace_validation_mode)
+      @namespaces_cache = nil
       self
     rescue ValidationError => e
       # Re-raise as NamespaceError, provide attributes for error context
@@ -103,15 +108,16 @@ module Moxml
         adapter.set_namespace(
           @native,
           adapter.create_namespace(@native, *ns_or_hash.to_a.first,
-                                   namespace_uri_mode: context.config.namespace_uri_mode),
+                                   namespace_validation_mode: context.config.namespace_validation_mode),
         )
       else
         adapter.set_namespace(@native, ns_or_hash&.native)
       end
+      @namespaces_cache = nil
     end
 
     def namespaces
-      adapter.namespace_definitions(@native).map do |ns|
+      @namespaces ||= adapter.namespace_definitions(@native).map do |ns|
         Namespace.new(ns, context)
       end
     end
@@ -136,6 +142,7 @@ module Moxml
 
     def text=(content)
       adapter.set_text_content(@native, normalize_xml_value(content))
+      invalidate_children_cache!
     end
 
     def inner_text
@@ -149,6 +156,7 @@ module Moxml
     def inner_xml=(xml)
       doc = context.parse("<root>#{xml}</root>")
       adapter.replace_children(@native, doc.root.children.map(&:native))
+      invalidate_children_cache!
     end
 
     # Fluent interface methods

data/lib/moxml/entity_registry.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require "json"
+require "set"
 
 module Moxml
   # EntityRegistry maintains a knowledge base of XML entity definitions.
@@ -26,6 +27,9 @@ module Moxml
     # W3C entity data file name
     ENTITY_DATA_FILE = "w3c_entities.json"
 
+    # Standard XML predefined entities (XML spec §4.6)
+    STANDARD_CODEPOINTS = Set[0x26, 0x3C, 0x3E, 0x22, 0x27].freeze
+
     class << self
       # Get the raw entity data from the bundled JSON source
       # @return [Hash{String => String}] entity name to character mapping
@@ -153,6 +157,38 @@ module Moxml
       @by_codepoint[codepoint]&.first
     end
 
+    # Check if a codepoint is one of the 5 standard XML predefined entities
+    # @param codepoint [Integer] Unicode codepoint
+    # @return [Boolean]
+    def standard_entity?(codepoint)
+      STANDARD_CODEPOINTS.include?(codepoint)
+    end
+
+    # Determine if an entity reference should be restored for a codepoint.
+    # Standard XML entities are always restored (required by XML spec).
+    # Non-standard entities are only restored when restore_entities is enabled.
+    # @param codepoint [Integer] Unicode codepoint
+    # @param config [Moxml::Config] configuration object
+    # @return [Boolean]
+    def should_restore?(codepoint, config:)
+      name = primary_name_for_codepoint(codepoint)
+      return false unless name
+      return true if standard_entity?(codepoint)
+
+      config.restore_entities
+    end
+
+    # Returns the set of codepoints that could potentially be restored as entities.
+    # Used by DocumentBuilder for O(1) fast-path checks.
+    # @return [Set<Integer>]
+    def restorable_codepoints
+      @restorable_codepoints ||= if @by_name.empty?
+                                   STANDARD_CODEPOINTS
+                                 else
+                                   Set.new(@by_name.values).freeze
+                                 end
+    end
+
     # Register additional entities
     # @param entities [Hash{String => Integer}] name => codepoint mapping
     # @return [self]

data/lib/moxml/node.rb

@@ -16,8 +16,8 @@ module Moxml
 
     def initialize(native, context)
       @context = context
-      # @native = adapter.patch_node(native)
       @native = native
+      @parent_node = nil
     end
 
     def document
@@ -29,9 +29,10 @@ module Moxml
     end
 
     def children
-      NodeSet.new(
+      @children ||= NodeSet.new(
         adapter.children(@native).map { adapter.patch_node(_1, @native) },
         context,
+        self,
       )
     end
 
@@ -46,29 +47,37 @@ module Moxml
     def add_child(node)
       node = prepare_node(node)
       adapter.add_child(@native, node.native)
+      node.instance_variable_set(:@parent_node, self)
+      invalidate_children_cache!
       self
     end
 
     def add_previous_sibling(node)
       node = prepare_node(node)
       adapter.add_previous_sibling(@native, node.native)
+      invalidate_parent_children_cache!
       self
     end
 
     def add_next_sibling(node)
       node = prepare_node(node)
       adapter.add_next_sibling(@native, node.native)
+      invalidate_parent_children_cache!
       self
     end
 
     def remove
+      invalidate_parent_children_cache!
       adapter.remove(@native)
+      invalidate_children_cache!
       self
     end
 
     def replace(node)
       node = prepare_node(node)
+      invalidate_parent_children_cache!
       adapter.replace(@native, node.native)
+      invalidate_children_cache!
       self
     end
 
@@ -229,6 +238,18 @@ module Moxml
       context.config.adapter
     end
 
+    # Invalidate cached children. Called by mutation methods
+    # and by Element attribute/namespace caches.
+    def invalidate_children_cache!
+      @children = nil
+    end
+
+    # Invalidate parent's cached children when this node
+    # is removed/replaced from its parent's child list.
+    def invalidate_parent_children_cache!
+      @parent_node&.invalidate_children_cache!
+    end
+
     private
 
     def prepare_node(node)

data/lib/moxml/node_set.rb

@@ -6,60 +6,72 @@ module Moxml
 
     attr_reader :nodes, :context
 
-    def initialize(nodes, context)
+    def initialize(nodes, context, parent_node = nil)
       @nodes = Array(nodes)
       @context = context
+      @wrapped = Array.new(@nodes.size)
+      @parent_node = parent_node
     end
 
     def each
       return to_enum(:each) unless block_given?
 
-      nodes.each { |node| yield Moxml::Node.wrap(node, context) }
+      @nodes.each_with_index do |node, i|
+        @wrapped[i] ||= wrap_with_parent(node)
+        yield @wrapped[i]
+      end
       self
     end
 
     def [](index)
       case index
       when Integer
-        Moxml::Node.wrap(nodes[index], context)
+        actual = index.negative? ? @nodes.size + index : index
+        return nil unless actual >= 0 && actual < @nodes.size
+
+        @wrapped[actual] ||= wrap_with_parent(@nodes[actual])
       when Range
-        NodeSet.new(nodes[index], context)
+        self.class.new(@nodes[index], @context)
       end
     end
 
     def first(n = nil)
       if n.nil?
-        Moxml::Node.wrap(nodes.first, context)
+        @nodes.empty? ? nil : self[0]
       else
-        nodes.first(n).map { |node| Moxml::Node.wrap(node, context) }
+        n.times.filter_map { |i| self[i] }
       end
     end
 
     def last
-      Moxml::Node.wrap(nodes.last, context)
+      @nodes.empty? ? nil : self[@nodes.size - 1]
     end
 
     def empty?
-      nodes.empty?
+      @nodes.empty?
     end
 
     def size
-      nodes.size
+      @nodes.size
     end
     alias length size
 
     def to_a
-      map { |node| node }
+      @nodes.each_with_index do |_node, i|
+        @wrapped[i] ||= wrap_with_parent(@nodes[i])
+      end
+      @wrapped.compact
     end
 
     def +(other)
-      self.class.new(nodes + other.nodes, context)
+      self.class.new(@nodes + other.nodes, @context)
     end
 
     def <<(node)
       # If it's a wrapped Moxml node, unwrap to native before storing
       native_node = node.respond_to?(:native) ? node.native : node
       @nodes << native_node
+      @wrapped << nil
       self
     end
     alias push <<
@@ -78,14 +90,14 @@ module Moxml
           true
         end
       end
-      self.class.new(unique_natives, context)
+      self.class.new(unique_natives, @context)
     end
 
     def ==(other)
       self.class == other.class &&
         length == other.length &&
-        nodes.each_with_index.all? do |node, index|
-          Moxml::Node.wrap(node, context) == other[index]
+        @nodes.each_with_index.all? do |_node, index|
+          self[index] == other[index]
         end
     end
 
@@ -103,8 +115,24 @@ module Moxml
     def delete(node)
       # If it's a wrapped Moxml node, unwrap to native
       native_node = node.respond_to?(:native) ? node.native : node
-      @nodes.delete(native_node)
+      idx = @nodes.index(native_node)
+      if idx
+        @nodes.delete_at(idx)
+        @wrapped.delete_at(idx)
+      else
+        @nodes.delete(native_node)
+      end
       self
     end
+
+    private
+
+    def wrap_with_parent(native_node)
+      wrapped = Moxml::Node.wrap(native_node, @context)
+      if @parent_node && wrapped
+        wrapped.instance_variable_set(:@parent_node, @parent_node)
+      end
+      wrapped
+    end
   end
 end

data/lib/moxml/version.rb

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

data/lib/moxml/xml_utils.rb

@@ -81,7 +81,7 @@ module Moxml
     end
 
     def validate_prefix(prefix)
-      return if prefix.match?(/\A[a-zA-Z_][\w-]*\z/)
+      return if prefix.match?(/\A[a-zA-Z_][\w.-]*\z/)
 
       raise ValidationError, "Invalid namespace prefix: #{prefix}"
     end

data/spec/integration/shared_examples/edge_cases.rb

@@ -95,6 +95,9 @@ RSpec.shared_examples "Moxml Edge Cases" do
       if context.config.adapter_name == :libxml
         skip "LibXML cannot query empty default namespace with XPath (documented limitation)"
       end
+      if context.config.adapter_name == :nokogiri
+        skip "Nokogiri XPath does not support querying empty namespace with xmlns prefix mapping"
+      end
       xml = <<~XML
         <root xmlns="http://default1.org">
           <child xmlns="http://default2.org">

data/spec/moxml/adapter/oga_spec.rb

@@ -12,6 +12,22 @@ RSpec.describe Moxml::Adapter::Oga do
 
   it_behaves_like "xml adapter"
 
+  describe "serialization" do
+    it "does not duplicate XML declarations when declaration nodes repeat" do
+      context = Moxml::Context.new(:oga)
+      doc = context.create_document
+
+      doc.add_child(doc.create_declaration("1.0", "UTF-8"))
+      doc.add_child(doc.create_declaration("1.0", "UTF-8"))
+      doc.add_child(doc.create_element("root"))
+
+      serialized = doc.to_xml
+
+      expect(serialized.scan("<?xml").size).to eq(1)
+      expect(serialized).to include("<root></root>")
+    end
+  end
+
   describe "entity handling" do
     it "preserves non-breaking space through parse and serialize round-trip" do
       xml = "<root>Item&nbsp;One</root>"
@@ -103,4 +119,50 @@ RSpec.describe Moxml::Adapter::Oga do
       expect(serialized).not_to include("\x01")
     end
   end
+
+  describe "doctype handling" do
+    it "correctly parses PUBLIC doctype" do
+      xml = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html/>'
+      doc = described_class.parse(xml)
+      doctype = doc.children.find { |c| c.is_a?(Moxml::Doctype) }
+
+      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 "correctly parses SYSTEM doctype" do
+      xml = '<!DOCTYPE config SYSTEM "config.dtd"><config/>'
+      doc = described_class.parse(xml)
+      doctype = doc.children.find { |c| c.is_a?(Moxml::Doctype) }
+
+      expect(doctype.name).to eq("config")
+      expect(doctype.external_id).to be_nil
+      expect(doctype.system_id).to eq("config.dtd")
+    end
+
+    it "correctly parses simple doctype" do
+      xml = "<!DOCTYPE html><html/>"
+      doc = described_class.parse(xml)
+      doctype = doc.children.find { |c| c.is_a?(Moxml::Doctype) }
+
+      expect(doctype.name).to eq("html")
+      expect(doctype.external_id).to be_nil
+      expect(doctype.system_id).to be_nil
+    end
+
+    it "round-trips PUBLIC doctype" do
+      xml = '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"><html/>'
+      doc = described_class.parse(xml)
+
+      expect(doc.to_xml).to include('PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd"')
+    end
+
+    it "round-trips SYSTEM doctype" do
+      xml = '<!DOCTYPE config SYSTEM "config.dtd"><config/>'
+      doc = described_class.parse(xml)
+
+      expect(doc.to_xml).to include('SYSTEM "config.dtd"')
+    end
+  end
 end

data/spec/moxml/adapter/shared_examples/adapter_contract.rb

@@ -4,18 +4,7 @@
 # A better way is to run it through Moxml wrappers
 RSpec.shared_examples "xml adapter" do
   let(:xml) do
-    <<~XML
-      <?xml version="1.0"?>
-      <root xmlns="http://example.org" xmlns:x="http://example.org/x">
-        <child id="1">Text</child>
-        <child id="2"/>
-        <x:special>
-          <![CDATA[Some <special> text]]>
-          <!-- A comment -->
-          <?pi target?>
-        </x:special>
-      </root>
-    XML
+    '<?xml version="1.0"?><root xmlns="http://example.org" xmlns:x="http://example.org/x"><child id="1">Text</child><child id="2"/><x:special><![CDATA[Some <special> text]]><!-- A comment --><?pi target?></x:special></root>'
   end
 
   describe ".parse" do

data/spec/moxml/allocation_benchmark_spec.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "support/allocation_helper"
+
+# Detailed allocation benchmarks — only run with RUN_PERFORMANCE=1.
+# These measure exact allocation counts and compare across adapters.
+RSpec.describe "Moxml allocation benchmarks", :performance do
+  shared_examples "reduced allocations" do |adapter_name|
+    let(:ctx) { Moxml::Context.new(adapter_name) }
+
+    it "parse allocates fewer objects than a 100-element baseline" do
+      xml = generate_xml(100)
+      allocs = AllocationHelper.count_allocations { ctx.parse(xml) }
+      # Before lazy parse: ~18,000 allocations for 100 elements via DocumentBuilder
+      # After lazy parse: should be dramatically less (document wrapper + root only)
+      expect(allocs).to be < 5000,
+                        "Expected <5000 allocations for 100-element parse, got #{allocs}"
+    end
+
+    it "parse + root access is allocation-efficient" do
+      xml = generate_xml(50)
+      allocs = AllocationHelper.count_allocations do
+        doc = ctx.parse(xml)
+        doc.root.name
+      end
+      expect(allocs).to be < 2000,
+                        "Expected <2000 allocations for parse + root.name, got #{allocs}"
+    end
+
+    it "children access is cached (repeated calls don't increase allocations)" do
+      xml = "<root><a/><b/><c/></root>"
+      doc = ctx.parse(xml)
+      root = doc.root
+
+      allocs1 = AllocationHelper.count_allocations { root.children.to_a }
+      allocs2 = AllocationHelper.count_allocations { root.children.to_a }
+
+      # Second call should allocate fewer objects because children are cached
+      expect(allocs2).to be <= allocs1,
+                         "Second children.to_a (#{allocs2}) should allocate <= first (#{allocs1})"
+    end
+
+    it "attributes access is cached" do
+      xml = '<root a="1" b="2" c="3"><child d="4"/></root>'
+      doc = ctx.parse(xml)
+      root = doc.root
+
+      allocs1 = AllocationHelper.count_allocations { root.attributes }
+      allocs2 = AllocationHelper.count_allocations { root.attributes }
+
+      expect(allocs2).to be <= allocs1,
+                         "Second attributes call (#{allocs2}) should allocate <= first (#{allocs1})"
+    end
+
+    it "namespaces access is cached" do
+      xml = '<root xmlns:a="http://a.com" xmlns:b="http://b.com"><a:child/></root>'
+      doc = ctx.parse(xml)
+      root = doc.root
+
+      allocs1 = AllocationHelper.count_allocations { root.namespaces }
+      allocs2 = AllocationHelper.count_allocations { root.namespaces }
+
+      expect(allocs2).to be <= allocs1,
+                         "Second namespaces call (#{allocs2}) should allocate <= first (#{allocs1})"
+    end
+
+    it "NodeSet iteration is cached (second iteration allocates less)" do
+      xml = generate_xml(20)
+      doc = ctx.parse(xml)
+      root = doc.root
+
+      allocs1 = AllocationHelper.count_allocations do
+        root.children.each do |_c|
+        end
+      end
+      allocs2 = AllocationHelper.count_allocations do
+        root.children.each do |_c|
+        end
+      end
+
+      expect(allocs2).to be <= allocs1,
+                         "Second NodeSet iteration (#{allocs2}) should allocate <= first (#{allocs1})"
+    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 "reduced allocations", adapter_name
+    end
+  end
+end