moxml 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e82117ebd56032bed4f9edffbb2714dec306b7bec52999193ef69fe62835ab9
-  data.tar.gz: 824fb9a07952249c2c97e650d5610d90c53ee23f279980aa5987e2a53922d74a
+  metadata.gz: d2a6cac576f8bc4819d27a22825f7ab11fd35a004113c70d6c4986adf542d844
+  data.tar.gz: 8f7cbfa869296d65002a6d2b74399ede57b16c2bcc25f4c4c7e9ccab611f5be6
 SHA512:
-  metadata.gz: 845a7de92860b25e68353e14efee1cc0015abfdc5a32f526b0baf1c45870e2966c1db6560eb45267a2fd0beab62936063493ac559fcca4317feffdcd0e54042a
-  data.tar.gz: 8242097334c0d1287bcc5c61658042e095ca1a34e375ff034c1504b9607f272937d62bd3ded2c439f45e7d6ae71ea58d86f5af37992858ab9a5fbadbe31fe738
+  metadata.gz: e5b6bf4775a56f4d4fd18cea369d84463085c4df14bdef0ee0ad818ff734864e658bfc41c81bf0e6989cdff2b4ffdff69c74bfc512a7b2debecadd7a892432b6
+  data.tar.gz: daf1b85571460bbde0553a52603f255577918dd9eb2e9faf37cb156738277bef51d5bfadc207b74d17177d3f281d9ae4ce4b2db571e22ad112bb595291d124c8

data/lib/compat/opal/moxml_boot.rb

@@ -25,6 +25,7 @@ require "moxml/doctype"
 require "moxml/entity_reference"
 require "moxml/entity_registry"
 require "moxml/entity"
+require "moxml/entity/restorer"
 require "moxml/entity/reference"
 require "moxml/xml_emitter"
 require "moxml/adapter"
@@ -44,7 +45,6 @@ require "moxml/adapter/customized_oga/raw_value_override"
 require "moxml/adapter/customized_oga/xml_declaration"
 require "moxml/adapter/customized_oga/xml_generator"
 require "moxml/adapter/oga"
-require "moxml/document_builder"
 require "moxml/builder"
 require "moxml/context"
 require "moxml/config"

data/lib/moxml/adapter/base.rb

@@ -183,13 +183,6 @@ namespace_validation_mode: :strict)
           node
         end
 
-        def prepare_for_new_document(node, _target_doc)
-          # Hook for adapters that need special handling when moving nodes
-          # between documents (e.g., LibXML's document.import)
-          # Default: no-op for backward compatibility
-          node
-        end
-
         # Check if the native document has an XML declaration
         # @param native_doc the native document object
         # @param wrapper [Moxml::Document] the wrapper with has_xml_declaration flag
@@ -222,6 +215,16 @@ namespace_validation_mode: :strict)
           child_native
         end
 
+        # Whether `Node.wrap` may safely memoize the wrapper for this
+        # native across calls. Adapters whose parser hands back the
+        # same Ruby object for the same logical node (nokogiri, ox,
+        # oga, rexml, leptris) opt in (default true). Adapters that
+        # mint a new Ruby object per access (libxml) opt out so the
+        # identity map does not accumulate dead entries.
+        def wrappers_recyclable?
+          true
+        end
+
         # Returns all namespaces in scope for this element, including
         # inherited from ancestors. Adapters with native support (Nokogiri)
         # override this. Default walks the ancestor chain.

data/lib/moxml/adapter/leptris.rb

@@ -559,8 +559,16 @@ module Moxml
         # @return [Array, Object, nil] native results, or nil when the
         #   query must run on the Ruby engine
         def native_xpath(node, expression, namespaces, first_only: false)
-          return nil unless node.is_a?(::Leptris::XML::Document)
+          return nil unless native_context_node?(node)
           return nil unless native_expression?(expression)
+          # The binding reports the root element parentless while moxml
+          # roots it at the document, so parent-axis queries from the
+          # root element keep the Ruby engine.
+          if node.is_a?(::Leptris::XML::Element) &&
+              node.document&.root.equal?(node) &&
+              expression_uses_parent_axis?(expression)
+            return nil
+          end
 
           compiled = NATIVE_XPATH_CACHE.get_or_set(expression) do
             ::Leptris::XML::XPath.compile(expression)
@@ -584,6 +592,27 @@ module Moxml
           nil
         end
 
+        def native_context_node?(node)
+          node.is_a?(::Leptris::XML::Document) ||
+            node.is_a?(::Leptris::XML::Element)
+        end
+
+        def expression_uses_parent_axis?(expression)
+          ast = XPath::Parser.parse_with_cache(expression)
+          contains_parent_axis?(ast)
+        rescue XPath::SyntaxError
+          true
+        end
+
+        def contains_parent_axis?(ast)
+          return true if ast.type == :parent
+          return true if ast.type == :axis && ast.children.first == "parent"
+
+          ast.children.any? do |child|
+            child.is_a?(XPath::AST::Node) && contains_parent_axis?(child)
+          end
+        end
+
         # Document-context queries without variable references,
         # attribute-node results, or the nokogiri-compat xmlns:
         # reserved prefix convention.

data/lib/moxml/adapter/libxml.rb

@@ -8,7 +8,6 @@ module Moxml
   module Adapter
     class Libxml < Base
       autoload :EntityRefRegistry, "moxml/adapter/libxml/entity_ref_registry"
-      autoload :EntityRestorer, "moxml/adapter/libxml/entity_restorer"
 
       # Wrapper class to store DOCTYPE information
       class DoctypeWrapper
@@ -68,6 +67,13 @@ module Moxml
           doc.root = element
         end
 
+        # libxml-ruby mints a fresh Ruby object for the same C node on
+        # each access; the wrapper identity map would accumulate dead
+        # entries without bound at full mutation throughput.
+        def wrappers_recyclable?
+          false
+        end
+
         def parse(xml, options = {}, _context = nil)
           # LibXML doesn't preserve DOCTYPE during parsing, so we need to extract it manually
           xml_string = if xml.is_a?(String)
@@ -121,10 +127,7 @@ module Moxml
 
           ctx = _context || Context.new(:libxml)
           # Single parse path: wrap libxml's already-complete C-parsed tree
-          # directly (same pattern as nokogiri/ox). The previous
-          # DocumentBuilder.build path walked the entire parsed tree and
-          # re-added every node to a fresh moxml-managed document, which
-          # made parse O(N) Ruby work on top of an already-complete parse.
+          # directly (same pattern as the other adapters).
           # Doctype/declaration/PI attachments set above remain on
           # native_doc, so the serialize path still sees them.
           #
@@ -134,7 +137,7 @@ module Moxml
           # path; the restoration walk is just one of potentially several
           # post-processing steps and doesn't fork the construction.
           doc = Document.new(native_doc, ctx)
-          EntityRestorer.new(doc).run if ctx.config.restore_entities
+          Entity::Restorer.new(doc).run if ctx.config.restore_entities
           doc
         end
 
@@ -219,7 +222,7 @@ module Moxml
           return :unknown unless node
 
           # Fast path: native libxml nodes are the vast majority during
-          # parse traversal (DocumentBuilder visits raw libxml children).
+          # parse traversal (wrapping visits raw libxml children).
           # Skip the wrapper checks below for them.
           if node.is_a?(::LibXML::XML::Node)
             return NATIVE_NODE_TYPE_MAP[node.node_type] || :unknown
@@ -1010,18 +1013,17 @@ module Moxml
 
             if native_node.root
               indent_size = options[:indent].is_a?(Integer) && options[:indent].positive? ? options[:indent] : 0
-              # Custom serializer emits newlines AND indentation directly —
-              # no separate add_newlines_to_xml / indent_xml passes.
               # `eref_active` is computed once here and threaded through the
               # recursion so that the per-element `attachments.key?` Monitor
               # sync only fires for docs that actually have entity refs.
               eref_active = entity_ref_registry(native_node).active?
-              root_output = serialize_element_with_namespaces(
+              root_output = native_root_output(native_node, indent_size)
+              root_output ||= serialize_element_with_namespaces(
                 native_node.root,
-                true,
-                indent_size,
-                0,
-                eref_active: eref_active,
+                  true,
+                  indent_size,
+                  0,
+                  eref_active: eref_active,
               )
 
               output << "\n" << root_output unless output.empty?
@@ -1034,8 +1036,48 @@ module Moxml
           end
         end
 
+        # Possessive-quantifier form: no backtracking, so pathological
+        # attribute content cannot blow up the expansion pass.
+        EMPTY_ELEMENT_EXPANSION_RE = %r{
+          <([A-Za-z_][\w.:-]*+)
+          ((?:"[^"]*+"|'[^']*+'|[^<>"'/]++)*+)
+          />
+        }x
+        private_constant :EMPTY_ELEMENT_EXPANSION_RE
+
+        # Serialize the root subtree with libxml's C serializer plus
+        # moxml-canonical corrections — roughly 25x faster and ~2600x
+        # fewer allocations than the Ruby walker. Returns nil whenever
+        # a guard says the walker is still required.
+        def native_root_output(native_doc, indent_size)
+          return nil unless indent_size == 2
+          return nil if entity_ref_registry(native_doc).active?
+
+          output = native_doc.root.to_s
+
+          # The walker strips prefixed names on parsed namespaced
+          # children; that behavior is load-bearing, so namespaced
+          # output keeps the walker.
+          return nil if output.include?("xmlns")
+
+          # Layout: pull closing tags onto the last child's line
+          output = output.gsub(/\n[ \t]*(<\/[\w.:-]+>)/, '\1')
+
+          if output.include?("/>")
+            # A literal "/>" inside a comment or CDATA section would be
+            # falsely expanded — the segment-aware walker is correct here
+            return nil if output.include?("<!--") || output.include?("<![CDATA[")
+
+            output = output.gsub(EMPTY_ELEMENT_EXPANSION_RE, '<\1\2></\1>')
+          end
+
+          # Native escapes attribute apostrophes; moxml keeps them literal
+          output.gsub("&apos;", "'")
+          
+        end
+
         # Shallow duplication: copies the node itself (name, attrs, namespaces)
-        # but NOT its descendants. This is what DocumentBuilder needs — it
+        # but NOT its descendants (deep duplication composes this).
         # walks the source tree and re-adds children one at a time via
         # add_child, so a deep copy here would be done only to be stripped
         # by replace_children, then rebuilt — O(N²) waste on parse.
@@ -1061,7 +1103,8 @@ module Moxml
               node
             end
           when :element
-            shallow_duplicate_element(native_node)
+            # Public dup contract: a full deep copy of the subtree
+            deep_duplicate_node(native_node)
           when :text
             ::LibXML::XML::Node.new_text(native_node.content)
           when :cdata
@@ -1106,15 +1149,6 @@ module Moxml
           end
         end
 
-        def prepare_for_new_document(node, target_doc)
-          return node unless node && target_doc
-
-          # For LibXML, we need to duplicate ALL nodes to avoid
-          # document ownership issues. Simply importing doesn't work
-          # because nodes from the parsed document still have references.
-          duplicate_node(node)
-        end
-
         def has_declaration?(native_doc, wrapper)
           decl = attachments.get(native_doc, :declaration)
           if decl

data/lib/moxml/adapter/oga.rb

@@ -40,8 +40,23 @@ module Moxml
             )
           end
 
+          # Oga parses multiple root elements leniently; the moxml
+          # contract requires a single root. to_a because the vendored
+          # fork's NodeSet#count ignores its block.
+          roots = native_doc.children.to_a.count do |child|
+            child.instance_of?(::Oga::XML::Element)
+          end
+          if roots > 1
+            raise Moxml::ParseError.new(
+              "multiple root elements",
+              source: xml.is_a?(String) ? xml[0..100] : nil,
+            )
+          end
+
           ctx = _context || Context.new(:oga)
-          DocumentBuilder.new(ctx).build(native_doc)
+          doc = Document.new(native_doc, ctx)
+          Entity::Restorer.new(doc).run if ctx.config.restore_entities
+          doc
         end
 
         # SAX parsing implementation for Oga.
@@ -239,6 +254,38 @@ module Moxml
           node.parent if node.is_a?(::Oga::XML::Node)
         end
 
+        # Oga's Node#dup shallow-copies the ivars, leaving attributes
+        # and children shared with the original; the public dup
+        # contract needs a full deep copy.
+        def duplicate_node(node)
+          case node
+          when ::Oga::XML::Element
+            copy = ::Oga::XML::Element.new(name: node.name)
+            copy.namespace_name = node.namespace_name if node.namespace_name
+            node.attributes.each do |attr|
+              copy.add_attribute(::Oga::XML::Attribute.new(
+                                   name: attr.name,
+                                   namespace_name: attr.namespace_name,
+                                   value: attr.value,
+                                 ))
+            end
+            node.children.each do |child|
+              copy.children << duplicate_node(child)
+            end
+            copy
+          when ::Oga::XML::Text
+            ::Oga::XML::Text.new(text: node.text)
+          when ::Oga::XML::Cdata
+            ::Oga::XML::Cdata.new(text: node.text)
+          when ::Oga::XML::Comment
+            ::Oga::XML::Comment.new(text: node.text)
+          when ::Oga::XML::ProcessingInstruction
+            ::Oga::XML::ProcessingInstruction.new(name: node.name, text: node.text)
+          else
+            node.dup
+          end
+        end
+
         def next_sibling(node)
           node.next
         end

data/lib/moxml/adapter/rexml.rb

@@ -41,7 +41,9 @@ module Moxml
           end
 
           ctx = _context || Context.new(:rexml)
-          DocumentBuilder.new(ctx).build(native_doc)
+          doc = Document.new(native_doc, ctx)
+          Entity::Restorer.new(doc).run if ctx.config.restore_entities
+          doc
         end
 
         def extract_encoding_from_xml(xml)

data/lib/moxml/builder.rb

@@ -75,24 +75,6 @@ module Moxml
     end
 
     # Batch element creation
-    def elements(element_specs)
-      element_specs.each do |name, content_or_attrs|
-        if content_or_attrs.is_a?(Hash)
-          element(name, content_or_attrs)
-        else
-          element(name) { text(content_or_attrs) }
-        end
-      end
-    end
-
-    # Helper for creating namespaced elements
-    def ns_element(namespace_uri, name, attributes = {}, &block)
-      el = element(name, attributes, &block)
-      prefix = @namespaces.key(namespace_uri)
-      el.namespace = { prefix => namespace_uri } if prefix
-      el
-    end
-
     # Dynamic element creation DSL.
     # xml.schema(attrs) { } creates <schema> with those attributes.
     # Uses yield so blocks preserve the caller's self context.

data/lib/moxml/config.rb

@@ -78,7 +78,6 @@ module Moxml
     attr_reader :adapter_name, :default_line_ending
     attr_accessor :strict_parsing,
                   :default_encoding,
-                  :entity_encoding,
                   :default_indent,
                   :restore_entities,
                   :preload_entity_sets,
@@ -104,7 +103,6 @@ module Moxml
       @default_encoding = default_encoding || Config.default.default_encoding
       @default_indent = 2
       @default_line_ending = LINE_ENDING_LF
-      @entity_encoding = :basic
       @restore_entities = false
       @preload_entity_sets = []
       @entity_load_mode = :required

data/lib/moxml/context.rb

@@ -10,6 +10,30 @@ module Moxml
       # compare against it so every wrapper sees changes without
       # needing wrapper identity.
       @namespace_scope_generation = 0
+      # Native → wrapper identity map: repeated traversals hand back
+      # the same wrapper instead of allocating a fresh one per
+      # access. Keyed by object identity; re-keyed by
+      # Node#refresh_native! when an adapter swaps a native.
+      @wrappers = {}.compare_by_identity
+    end
+
+    def wrapper_for(native)
+      @wrappers[native]
+    end
+
+    def register_wrapper(native, wrapper)
+      # Safety valve + adapter opt-in. Adapters whose natives are
+      # recreated per access (libxml mints fresh Ruby objects for the
+      # same C node) opt out so the map does not accumulate dead
+      # entries; the default is opt-in.
+      return if @config&.adapter&.wrappers_recyclable? == false
+
+      @wrappers.clear if @wrappers.size >= 65_536
+      @wrappers[native] = wrapper
+    end
+
+    def unregister_wrapper(native)
+      @wrappers.delete(native)
     end
 
     def namespace_scope_generation

data/lib/moxml/document.rb

@@ -21,7 +21,7 @@ module Moxml
 
     def root
       root_element = adapter.root(@native)
-      root_element ? Element.new(root_element, context) : nil
+      root_element ? Moxml::Node.wrap(root_element, context) : nil
     end
 
     def create_element(name)

data/lib/moxml/entity/restorer.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+module Moxml
+  module Entity
+    # Restores configured character entities into explicit
+    # Moxml::Entity::Reference nodes after a native tree has been
+    # parsed and wrapped — for adapters whose parser resolves entities
+    # during parsing (libxml, and the restore_entities option on
+    # rexml/oga).
+    class Restorer
+      def initialize(doc)
+        @doc = doc
+        @ctx = doc.context
+        @registry = @ctx.entity_registry
+        @config = @ctx.config
+        @adapter = @ctx.config.adapter
+      end
+
+      def run
+        return unless @registry && @doc.root
+
+        walk(@doc.root)
+      end
+
+      private
+
+      def walk(element)
+        # Snapshot because we may add/remove siblings during the walk.
+        element.children.to_a.each do |child|
+          if child.is_a?(::Moxml::Text)
+            restore_text_node(child)
+          elsif child.is_a?(::Moxml::Element)
+            walk(child)
+          end
+        end
+      end
+
+      # Includes the adapter limitation that adjacent native text
+      # nodes get merged.
+      def restore_text_node(text_node)
+        content = text_node.content
+        return unless content
+
+        chunks = chunk_text(content)
+        return if chunks.size == 1 && chunks.first.first == :text
+
+        parent = text_node.parent
+        return unless parent
+
+        text_node.remove
+        chunks.each { |type, payload| append_chunk(parent, type, payload) }
+      end
+
+      def chunk_text(content)
+        chunks = []
+        buffer = +""
+        restorable = @registry.restorable_codepoints
+
+        content.each_char do |char|
+          cp = char.ord
+          if restorable.include?(cp) &&
+              (name = @registry.primary_name_for_codepoint(cp)) &&
+              @registry.should_restore?(cp, config: @config)
+            unless buffer.empty?
+              chunks << [:text, buffer.dup]
+              buffer.clear
+            end
+            chunks << [:eref, name]
+          else
+            buffer << char
+          end
+        end
+
+        chunks << [:text, buffer.dup] unless buffer.empty?
+        chunks
+      end
+
+      def append_chunk(parent, type, payload)
+        case type
+        when :text
+          parent.add_child(::Moxml::Text.new(
+                             @adapter.create_native_text(payload), @ctx
+                           ))
+        when :eref
+          parent.add_child(
+            ::Moxml::EntityReference.new(
+              @adapter.create_native_entity_reference(payload),
+              @ctx,
+            ),
+          )
+        end
+      end
+    end
+  end
+end

data/lib/moxml/entity.rb

@@ -29,6 +29,7 @@ module Moxml
   # shared, single-sourced parts.
   module Entity
     autoload :Reference, "moxml/entity/reference"
+    autoload :Restorer, "moxml/entity/restorer"
 
     # Marker for adapters that resolve entities during parsing.
     # U+FFFC (Object Replacement Character) + U+FEFF (BOM) is a

data/lib/moxml/entity_registry.rb

@@ -199,7 +199,7 @@ module Moxml
     end
 
     # Returns the set of codepoints that could potentially be restored as entities.
-    # Used by DocumentBuilder for O(1) fast-path checks.
+    # Used by Entity::Restorer for O(1) fast-path checks.
     # @return [Set<Integer>]
     def restorable_codepoints
       @restorable_codepoints ||= if @by_name.empty?

data/lib/moxml/error.rb

@@ -106,27 +106,6 @@ module Moxml
     end
   end
 
-  # Error raised when serialization fails
-  class SerializationError < Error
-    attr_reader :node, :adapter, :format
-
-    def initialize(message, node: nil, adapter: nil, format: nil)
-      @node = node
-      @adapter = adapter
-      @format = format
-      super(message)
-    end
-
-    def to_s
-      msg = super
-      msg += "\n  Node: <#{@node.name}>" if @node.is_a?(Element) || @node.is_a?(Attribute)
-      msg += "\n  Adapter: #{@adapter}" if @adapter
-      msg += "\n  Format: #{@format}" if @format
-      msg += "\n  Hint: Check that the node structure is valid for serialization"
-      msg
-    end
-  end
-
   # Error raised when document structure is invalid
   class DocumentStructureError < Error
     attr_reader :attempted_operation, :current_state
@@ -146,27 +125,6 @@ module Moxml
     end
   end
 
-  # Error raised when attribute operations fail
-  class AttributeError < Error
-    attr_reader :attribute_name, :element, :value
-
-    def initialize(message, name: nil, element: nil, value: nil)
-      @attribute_name = name
-      @element = element
-      @value = value
-      super(message)
-    end
-
-    def to_s
-      msg = super
-      msg += "\n  Attribute: #{@attribute_name}" if @attribute_name
-      msg += "\n  Element: <#{@element.name}>" if @element.is_a?(Element)
-      msg += "\n  Value: #{@value.inspect}" if @value
-      msg += "\n  Hint: Verify attribute name follows XML naming rules"
-      msg
-    end
-  end
-
   # Error raised when a feature is not implemented by an adapter
   class NotImplementedError < Error
     attr_reader :feature, :adapter

data/lib/moxml/node.rb

@@ -21,7 +21,12 @@ module Moxml
     # Update native reference after identity-changing operations
     # (e.g., LibXML doc.root= creates a new Ruby wrapper)
     def refresh_native!(new_native)
-      @native = new_native
+      unless new_native.equal?(@native)
+        context.unregister_wrapper(@native)
+        @native = new_native
+        context.register_wrapper(new_native, self)
+      end
+      self
     end
 
     def document
@@ -225,6 +230,41 @@ module Moxml
       NodeSet.new(natives, context)
     end
 
+    # Returns the siblings after this node, in document order.
+    #
+    # @return [NodeSet]
+    def following_siblings
+      parent = self.parent
+      return NodeSet.new([], context) unless parent
+
+      siblings = parent.children.to_a
+      index = siblings.index { |child| child.native.equal?(@native) }
+      return NodeSet.new([], context) if index.nil?
+
+      NodeSet.new(siblings[(index + 1)..].map(&:native), context)
+    end
+
+    # Returns the siblings before this node, in document order.
+    #
+    # @return [NodeSet]
+    def preceding_siblings
+      parent = self.parent
+      return NodeSet.new([], context) unless parent
+
+      siblings = parent.children.to_a
+      index = siblings.index { |child| child.native.equal?(@native) }
+      return NodeSet.new([], context) if index.nil?
+
+      NodeSet.new(siblings[0...index].map(&:native), context)
+    end
+
+    # Deep copy of the node (both dup and clone create deep copies for XML nodes)
+    def dup
+      Moxml::Node.wrap(adapter.duplicate_node(@native), context)
+    end
+
+    alias clone dup
+
     # Returns an XPath expression that uniquely locates this node within
     # its document. Positional predicates are emitted only when sibling
     # elements share the same qualified name, keeping paths minimal.
@@ -276,13 +316,6 @@ module Moxml
       text.strip.empty?
     end
 
-    # Deep copy of the node (both dup and clone create deep copies for XML nodes)
-    def dup
-      Moxml::Node.wrap(adapter.dup(@native), context)
-    end
-
-    alias clone dup
-
     def ==(other)
       self.class == other.class && @native == other.native
     end
@@ -325,10 +358,13 @@ module Moxml
     def self.wrap(node, context)
       return nil if node.nil?
 
+      cached = context.wrapper_for(node)
+      return cached if cached
+
       type = adapter(context).node_type(node)
       klass = node_type_map[type] || self
 
-      klass.new(node, context)
+      klass.new(node, context).tap { |wrapper| context.register_wrapper(node, wrapper) }
     end
 
     # Internal: Set the parent node for cache invalidation tracking.

data/lib/moxml/node_set.rb

@@ -64,7 +64,7 @@ module Moxml
     end
 
     def +(other)
-      self.class.new(@nodes + other.nodes, @context)
+      self.class.new(@nodes + other.nodes, @context, @parent_node)
     end
 
     def <<(node)