moxml 0.5.30 → 0.5.31

data/lib/moxml/adapter/libxml.rb

@@ -923,12 +923,23 @@ module Moxml
           native.name
         end
 
+        # libxml-ruby 5.x exposes no external/system ID accessor on
+        # the DTD node — the DOCTYPE source text is the only source,
+        # so re-derive from it (same DOCTYPE_RE as the parse path).
         def doctype_external_id(native)
-          native.external_id
+          if native.is_a?(DoctypeWrapper)
+            native.external_id
+          else
+            native.to_s[DOCTYPE_RE, 2]
+          end
         end
 
         def doctype_system_id(native)
-          native.system_id
+          if native.is_a?(DoctypeWrapper)
+            native.system_id
+          else
+            native.to_s[DOCTYPE_RE, 3] || native.to_s[DOCTYPE_RE, 4]
+          end
         end
 
         def xpath(node, expression, namespaces = nil)

data/lib/moxml/adapter/nokogiri.rb

@@ -12,12 +12,50 @@ module Moxml
           @attachments ||= Moxml::NativeAttachment.new
         end
 
+        def bare_set_qname_safe?
+          true
+        end
+
+        # Qualified-name reads are clean on this engine (verified by
+        # the expanded-name specs); markers restore in-line when the
+        # parse recorded them.
+        def bare_get_qname_safe?
+          true
+        end
+
+        # Fast bare-name read for Element#[]: the native call plus,
+        # only when the parse recorded entity markers, their
+        # restoration (the resolver path's other real semantic).
+        # The marker flag is constant per document — a WeakMap on
+        # the adapter beats the per-read document fetch + attachment
+        # hash chain.
+        def doc_entity_markers?(doc)
+          cache = (@doc_markers ||= ObjectSpace::WeakMap.new)
+          cached = cache[doc]
+          return cached unless cached.nil?
+
+          cache[doc] = attachments.get(doc, :entity_markers) == true
+        end
+
+        def bare_attr_value(element, name)
+          value = element[name.to_s]
+          if value.is_a?(String) && doc_entity_markers?(element.document)
+            restore_entities(value)
+          else
+            value
+          end
+        end
+
+        def native_identity_stable?
+          true
+        end
+
         def set_root(doc, element)
           doc.root = element
         end
 
         def parse(xml, options = {}, _context = nil)
-          processed_xml = preprocess_entities(xml)
+          processed_xml, entity_markers = Entity.preprocess_with_marker_flag(xml)
 
           # preprocess_entities always returns UTF-8, so tell Nokogiri to
           # parse as UTF-8 regardless of any original encoding option.
@@ -42,9 +80,20 @@ module Moxml
 
           # Use provided context if available, otherwise create new one
           ctx = _context || Context.new(:nokogiri)
+          attachments.set(native_doc, :entity_markers, entity_markers)
           Document.new(native_doc, ctx)
         end
 
+        # Tolerant HTML parsing through libxml2's HTML mode: implied
+        # html/head/body structure, void elements, lowercased names,
+        # the HTML named-entity table. Recovery is inherent —
+        # malformed input never raises.
+        def parse_html(html, _options = {}, _context = nil)
+          html_string = html.is_a?(IO) || html.is_a?(StringIO) ? html.read : html.to_s
+          native_doc = ::Nokogiri::HTML(html_string)
+          Document.new(native_doc, _context || Context.new(:nokogiri))
+        end
+
         # Nokogiri parses with `config.recover` unless strict, so
         # recoverable syntax errors land on `doc.errors` instead of
         # raising (issue #147).
@@ -386,9 +435,11 @@ module Moxml
 
         def xpath(node, expression, namespaces = nil)
           result = node.xpath(expression, namespaces)
-          # Adapter contract: Array<native> | scalar (count(),
-          # string-length(), boolean functions return scalars).
-          result.is_a?(Enumerable) ? result.to_a : result
+          # Adapter contract: Array<native> | LazyNodeSet | scalar
+          # (count(), string-length(), boolean functions return
+          # scalars). The native node-set passes through lazily —
+          # to_a would materialize every result wrapper up front.
+          result.is_a?(Enumerable) ? result.extend(Moxml::LazyNodeSet) : result
         rescue ::Nokogiri::XML::XPath::SyntaxError => e
           raise Moxml::XPathError.new(
             e.message,

data/lib/moxml/adapter/ox.rb

@@ -15,6 +15,14 @@ module Moxml
           @attachments ||= Moxml::NativeAttachment.new
         end
 
+        def bare_set_qname_safe?
+          true
+        end
+
+        def native_identity_stable?
+          true
+        end
+
         def set_root(doc, element)
           existing_root = root(doc)
           element.parent = doc if element.is_a?(::Ox::Node)

data/lib/moxml/adapter/rexml.rb

@@ -14,6 +14,14 @@ module Moxml
           @attachments ||= Moxml::NativeAttachment.new
         end
 
+        def bare_set_qname_safe?
+          true
+        end
+
+        def native_identity_stable?
+          true
+        end
+
         def parse(xml, options = {}, _context = nil)
           xml = "" if xml.nil?
 

data/lib/moxml/attribute_resolver.rb

@@ -29,6 +29,27 @@ module Moxml
     module_function
 
     # @return [Moxml::Attribute, nil] the matching attribute wrapper
+    # Value-only prefixed resolution for Element#[]: prefix
+    # resolution is the resolver's real work; the match step goes to
+    # the engine's expanded-name lookup where the adapter offers it,
+    # skipping the attribute-list materialization and per-attr URI
+    # probes. Bare names take Element#'s adapter fast path instead.
+    def resolve_value(element, name)
+      prefix, local = name.split(":", 2)
+      return nil if prefix == "xmlns"
+
+      uri = prefix_uri(element, prefix)
+      return nil if uri.nil?
+
+      adapter = element.context.config.adapter
+      if adapter.is_a?(Moxml::Adapter::Leptris)
+        return adapter.expanded_attr_value(element.native, uri, local)
+      end
+
+      attr = resolve(element, name)
+      attr&.value
+    end
+
     def resolve(element, name)
       name = name.to_s
       if name.include?(":")
@@ -91,6 +112,20 @@ module Moxml
         return value
       end
 
+      # Fast path: every adapter's set_attribute writes by qualified
+      # name, and XML cannot namespace an unprefixed attribute — so
+      # a bare-name set replaces only the no-namespace attribute and
+      # can never touch a namespaced p:<local> sibling. The full
+      # expanded-name resolve (wrap every attribute, resolve each
+      # prefix against in-scope namespaces) is only needed for
+      # prefixed names; it dominated programmatic-builder attribute
+      # writes.
+      if !name.include?(":") && adapter.bare_set_qname_safe?
+        adapter.set_attribute(element.native, name, value)
+        element.invalidate_attribute_cache!
+        return value
+      end
+
       existing = resolve(element, name)
       if existing
         existing.value = value

data/lib/moxml/c14n.rb

@@ -39,6 +39,11 @@ module Moxml
     #   :exclusive10  Exclusive C14N 1.0 (W3C REC-xml-exc-c14n-20020718)
     def self.canonicalize(node_or_xml, with_comments: false,
                           algorithm: :inclusive10, inclusive_namespaces: [])
+      if (native = native_inclusive10(node_or_xml, with_comments,
+                                      inclusive_namespaces))
+        return native
+      end
+
       engine_for(algorithm).canonicalize(
         node_or_xml,
         with_comments: with_comments,
@@ -46,6 +51,31 @@ module Moxml
       )
     end
 
+    # The leptris engine canonicalizes in C — 23x the Ruby reference.
+    # Delegated only for the exact default shape (Inclusive 1.0, no
+    # comments, no InclusiveNamespace prefix list) on wrappers whose
+    # adapter passed the NATIVE_C14N_BYTE_SAFE load probe; every
+    # other combination keeps the Ruby engine (node-set subsets,
+    # xml:base fixup, exclusive, 1.1 stay on the ported
+    # implementation regardless).
+    def self.native_inclusive10(node_or_xml, with_comments, inclusive_namespaces)
+      return nil if with_comments || !inclusive_namespaces.empty?
+      return nil unless algorithm_shape_inclusive10?(node_or_xml)
+
+      adapter = node_or_xml.context.config.adapter
+      return nil unless adapter == Moxml::Adapter::Leptris &&
+        Moxml::Adapter::Leptris.native_c14n_byte_safe?
+
+      node_or_xml.native.canonicalize(
+        ::Leptris::XML::FFI::C14N_1_0, nil,
+        mode: ::Leptris::XML::FFI::C14N_MODE_CANONICAL
+      )
+    end
+
+    def self.algorithm_shape_inclusive10?(node_or_xml)
+      node_or_xml.is_a?(Moxml::Element) || node_or_xml.is_a?(Moxml::Document)
+    end
+
     def self.canonicalize_inclusive10(node_or_xml, with_comments: false)
       Inclusive10.new.canonicalize(node_or_xml, with_comments: with_comments)
     end

data/lib/moxml/context.rb

@@ -2,6 +2,10 @@
 
 module Moxml
   class Context
+    # Opal's default runtime excludes ObjectSpace entirely; the weak
+    # registry needs WeakMap, so the strong Hash (with its
+    # wholesale-clear valve) covers that platform.
+    WEAK_WRAPPERS = !defined?(ObjectSpace::WeakMap).nil?
     attr_reader :config
 
     def initialize(adapter = nil)
@@ -14,7 +18,12 @@ module Moxml
       # 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
+      # WeakMap where available: entries die with their native —
+      # parse-and-drop workloads release wrappers, natives, and (via
+      # the binding's finalizer) the C subtrees, instead of pinning
+      # up to the old 65,536 wholesale-clear valve which also
+      # destroyed identity for live wrappers when it fired.
+      @wrappers = WEAK_WRAPPERS ? ObjectSpace::WeakMap.new : {}.compare_by_identity
     end
 
     def wrapper_for(native)
@@ -22,18 +31,26 @@ module Moxml
     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.
+      # 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
+      # The strong fallback (Opal) needs the wholesale-clear valve;
+      # the WeakMap registry is self-cleaning.
+      @wrappers.clear if @wrappers.is_a?(Hash) && @wrappers.size >= 65_536
       @wrappers[native] = wrapper
     end
 
+    # WeakMap has no delete — a nil value tombstones the entry (reads
+    # as a miss) and dies with the native like any other.
     def unregister_wrapper(native)
-      @wrappers.delete(native)
+      if WEAK_WRAPPERS
+        @wrappers[native] = nil
+      else
+        @wrappers.delete(native)
+      end
     end
 
     def namespace_scope_generation
@@ -74,6 +91,29 @@ module Moxml
       doc
     end
 
+    # Tolerant HTML4/5 parsing into the standard DOM: implied end
+    # tags, void elements, case-insensitive lowercased names, the
+    # HTML named-entity table, synthesized html/head/body. Supported
+    # by adapters with an engine HTML mode (leptris >= 1.9.80,
+    # nokogiri); others raise Moxml::AdapterError.
+    def parse_html(html, options = {})
+      config.adapter.parse_html(html, options, self)
+    end
+
+    # Streaming incremental parse (leptris): yields each completed
+    # element while parsing — :top_level yields the root's children,
+    # :full_document every element in completion (post-order) order.
+    # Memory stays bounded by the largest subtree, not the document
+    # (iterparse_file streams the file C-side). Yielded elements are
+    # parentless and valid only inside the block.
+    def iterparse(xml, mode: :top_level, &block)
+      config.adapter.iterparse(xml, mode, self, &block)
+    end
+
+    def iterparse_file(path, mode: :top_level, &block)
+      config.adapter.iterparse_file(path, mode, self, &block)
+    end
+
     # Parse then flatten in one call — see Moxml::Materializer
     # (issue #132). Yields records; returns an Enumerator when no
     # block is given.
@@ -128,6 +168,26 @@ module Moxml
       Builder.new(self).build(&block)
     end
 
+    # Frozen serialization defaults, memoized per context — Node#to_xml
+    # merged these from live config reads on every call (bulk element
+    # serialization pays a hash build + 4 chain derefs per element).
+    def default_serialize_options
+      @default_serialize_options ||= {
+        encoding: config.default_encoding,
+        indent: config.default_indent,
+        line_ending: config.default_line_ending,
+        expand_empty: true,
+      }.freeze
+    end
+
+    # The argless element.to_xml form resolves every option statically
+    # (no declaration for non-document nodes, context defaults for the
+    # rest) — this prebuilt frozen hash makes that path allocation-free.
+    def default_element_serialize_options
+      @default_element_serialize_options ||=
+        default_serialize_options.merge(no_declaration: true).freeze
+    end
+
     private
 
     def build_entity_registry

data/lib/moxml/document.rb

@@ -131,11 +131,11 @@ module Moxml
       # Handle different result types:
       # - Scalar values (from functions): return directly
       # - NodeSet: already wrapped, return directly
-      # - Array: wrap in NodeSet
+      # - Array / LazyNodeSet: wrap in NodeSet
       case result
       when NodeSet, Float, String, TrueClass, FalseClass, NilClass
         result
-      when Array
+      when Array, LazyNodeSet
         NodeSet.new(result, context)
       else
         # For other types, try to wrap in NodeSet

data/lib/moxml/element.rb

@@ -46,7 +46,9 @@ module Moxml
     # attributes only; prefixed names replace by namespace URI and
     # require a declared prefix. Cache coherence is the resolver's.
     def []=(name, value)
-      context.bump_namespace_scope_generation
+      # Every assign path (native set or value=) ends in
+      # invalidate_attribute_cache!, which bumps the generation —
+      # a leading bump here was one per write.
       Moxml::AttributeResolver.assign(self, name, normalize_xml_value(value))
     end
 
@@ -54,12 +56,25 @@ module Moxml
     # bare names match only no-namespace attributes; prefixed names
     # resolve through in-scope declarations to expanded names.
     def [](name)
-      cache = attribute_read_cache
       key = name.to_s
+      # Bare names on qualified-name engines: one adapter call with
+      # the adapter's own marker restoration (bare_attr_value). The
+      # resolver's expanded-name semantics only pay for prefixed
+      # names, where resolution is real work.
+      adapter = self.adapter
+      if !key.include?(":") && adapter.bare_get_qname_safe?
+        return adapter.bare_attr_value(@native, key)
+      end
+
+      cache = attribute_read_cache
       unless cache.key?(key)
-        cache[key] = Moxml::AttributeResolver.resolve(self, key)
+        cache[key] = if key.include?(":")
+                       Moxml::AttributeResolver.resolve_value(self, key)
+                     else
+                       Moxml::AttributeResolver.resolve(self, key)&.value
+                     end
       end
-      cache[key]&.value
+      cache[key]
     end
 
     def attribute(name)
@@ -92,11 +107,41 @@ module Moxml
     end
 
     def remove_attribute(name)
-      context.bump_namespace_scope_generation
+      # Both remove paths end in invalidate_attribute_cache!, which
+      # bumps the generation.
       Moxml::AttributeResolver.remove(self, name)
       self
     end
 
+    # Append a raw XML fragment's top-level nodes as children.
+    #
+    # Bulk construction rides the engine's parser instead of
+    # per-node create/attach calls — measured 2.0x faster than
+    # per-node building through the same adapter, and faster than
+    # per-node building on Nokogiri (the parse is C; the per-node
+    # path pays an FFI crossing per node).
+    #
+    # The fragment must be namespace-self-contained (declarations
+    # inside it ride along with the moved subtrees; prefixes relying
+    # on THIS element's scope must be spelled out in the fragment)
+    # and well-formed as the content of a single wrapper element —
+    # declarations and doctypes raise ParseError.
+    #
+    # @return [Moxml::Element] self
+    def append_xml(fragment)
+      if context.config.adapter_name == :ox
+        raise Moxml::AdapterError.new(
+          "append_xml is not supported by the Ox adapter (its customized node wrappers do not survive cross-document attachment)",
+          adapter: "Ox", operation: "append_xml",
+        )
+      end
+
+      wrapper = context.parse("<m>#{fragment}</m>")
+      children = wrapper.root.children.to_a
+      children.each { |child| add_child(child) }
+      self
+    end
+
     def add_namespace(prefix, uri)
       adapter.create_namespace(@native, prefix, uri,
                                namespace_validation_mode: context.config.namespace_validation_mode)

data/lib/moxml/lazy_node_set.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Moxml
+  # Marker for an adapter's native node-set result that NodeSet can
+  # hold without materializing the natives. The leptris binding's
+  # NodeSet mints one Ruby wrapper per result node in #to_a — the
+  # whole 900-node result set is built even when the caller only
+  # asks .size or .first — so the adapter hands the native set
+  # through instead. Contract: responds to length, empty?, [],
+  # each, to_a (yielding natives).
+  module LazyNodeSet
+    def size
+      length
+    end
+  end
+end

data/lib/moxml/native_attachment/native.rb

@@ -25,8 +25,13 @@ module Moxml
         @monitor = Monitor.new
       end
 
+      # Reads are lock-free: MRI Hash#[] is atomic under the GVL, and
+      # the only mid-write race (set assigns the inner hash before its
+      # key) resolves to a miss — the same answer as "not set yet",
+      # which every reader treats conservatively. This method sits on
+      # per-element hot paths (entity_bearing? on every serialize).
       def get(native, key)
-        @monitor.synchronize { @data[native.object_id]&.[](key) }
+        @data[native.object_id]&.[](key)
       end
 
       def set(native, key, value)
@@ -39,7 +44,8 @@ module Moxml
       end
 
       def key?(native, key)
-        @monitor.synchronize { @data[native.object_id]&.key?(key) || false }
+        h = @data[native.object_id]
+        !h.nil? && h.key?(key)
       end
 
       def delete(native, key)

data/lib/moxml/node.rb

@@ -35,6 +35,7 @@ module Moxml
     def clear_native_memo!
       @name = nil
       @attribute_cache = nil
+      @entity_bearing_gen = nil
     end
 
     def document
@@ -64,9 +65,12 @@ module Moxml
     def add_child(node)
       node = prepare_node(node)
       adapter.add_child(@native, node.native)
-      # Refresh native in case adapter changed identity (e.g., LibXML doc.root=)
-      refreshed = adapter.actual_native(node.native, @native)
-      node.refresh_native!(refreshed) if refreshed && refreshed != node.native
+      # Refresh native in case adapter changed identity (e.g., LibXML
+      # doc.root=); stable-identity adapters skip the round trip.
+      unless adapter.native_identity_stable?
+        refreshed = adapter.actual_native(node.native, @native)
+        node.refresh_native!(refreshed) if refreshed && refreshed != node.native
+      end
       node.parent_node = self
       # The adopted subtree's in-scope namespaces changed
       node.invalidate_namespace_cache!
@@ -113,23 +117,43 @@ module Moxml
       # Determine if we should include XML declaration
       # For Document nodes: check native then wrapper, unless explicitly overridden
       # For other nodes: default to no declaration unless explicitly set
-      serialize_options = default_options.merge(options)
-      serialize_options[:no_declaration] = !should_include_declaration?(options)
+      serialize_options = if options.empty? && !is_a?(Document)
+                            context.default_element_serialize_options
+                          else
+                            merged = context.default_serialize_options.merge(options)
+                            merged[:no_declaration] = !should_include_declaration?(options)
+                            merged
+                          end
 
       result = adapter.serialize(@native, serialize_options)
       result = apply_line_ending(result, serialize_options[:line_ending])
 
       # Restore entity markers to named entity references; skipped
       # when the adapter knows the document carries no markers.
-      result = adapter.restore_entities(result) if adapter.entity_bearing?(@native)
+      result = adapter.restore_entities(result) if entity_bearing?
       result
     end
 
+    # Memoized against the adapter's serialize generation — the
+    # entity-marker flag flips at parse and entity-reference mint,
+    # both adapter-level, and the generation bump is the invalidation
+    # signal. Adapters with static answers (base class) never bump.
+    def entity_bearing?
+      gen = adapter.serialize_generation
+      if @entity_bearing_gen == gen
+        @entity_bearing
+      else
+        @entity_bearing_gen = gen
+        @entity_bearing = adapter.entity_bearing?(@native)
+      end
+    end
+
     def xpath(expression, namespaces = {})
       result = adapter.xpath(@native, expression, namespaces)
-      # Adapter contract: Array<native> | scalar. Scalars (count(),
-      # string-length(), booleans) pass through unwrapped.
-      result.is_a?(Array) ? NodeSet.new(result, context) : result
+      # Adapter contract: Array<native> | LazyNodeSet | scalar.
+      # Scalars (count(), string-length(), booleans) pass through
+      # unwrapped; the set forms wrap lazily.
+      result.is_a?(Array) || result.is_a?(LazyNodeSet) ? NodeSet.new(result, context) : result
     end
 
     # Flattened post-order records for this subtree without
@@ -459,19 +483,6 @@ module Moxml
       end
     end
 
-    def default_options
-      {
-        encoding: context.config.default_encoding,
-        indent: context.config.default_indent,
-        line_ending: context.config.default_line_ending,
-        # The short format of empty tags in Oga and Nokogiri isn't configurable
-        # Oga: <empty /> (with a space)
-        # Nokogiri: <empty/> (without a space)
-        # The expanded format is enforced to avoid this conflict
-        expand_empty: true,
-      }
-    end
-
     def should_include_declaration?(options)
       return options[:declaration] if options.key?(:declaration)
       return options.fetch(:declaration, false) unless is_a?(Document)