moxml 0.5.149 → 0.5.151

data/lib/moxml/adapter/leptris.rb

@@ -71,6 +71,13 @@ module Moxml
         defined?(::Leptris::XML::NativeNode) &&
         Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.162.6")
 
+      # leptris-ruby#460: set-text by document+address, kind-dispatched
+      # in C — no binding twin mint per write. Face-probed, not
+      # version-gated (the floor admits bindings without it).
+      NATIVE_SET_BINDING_TEXT =
+        defined?(::Leptris::XML::Native) &&
+        ::Leptris::XML::Native.respond_to?(:set_binding_text)
+
       # 1.9.163.2's native layer returns UTF-8, unfrozen strings
       # (1.9.162.x answered ASCII-8BIT — the reads retagged with a
       # dup+force_encoding per call).
@@ -234,6 +241,16 @@ module Moxml
 
       XSD_SUPPORTED = NATIVE_XSD
 
+      # RELAX NG (moxml RelaxNG contract): the binding ships the RNG
+      # facade over the engine's Jing-compatible validator.
+      RELAXNG_SUPPORTED = begin
+        require "leptris/xml/relaxng"
+        defined?(::Leptris::XML::RelaxNG) &&
+          ::Leptris::XML::RelaxNG.respond_to?(:parse_file)
+      rescue LoadError
+        false
+      end
+
       # Schema#release (moxml#362.3, binding 1.9.342+): the
       # deterministic drop face — disarms the AutoPointer's GC
       # finalizer and frees now. Face-probed with the version
@@ -319,6 +336,40 @@ module Moxml
           ::Leptris::XML::XSD.compile_file(path)
         end
 
+        def relaxng_compile(schema_source)
+          unless RELAXNG_SUPPORTED
+            raise Moxml::NotImplementedError,
+                  "RELAX NG validation requires a leptris binding with the RNG face"
+          end
+
+          ::Leptris::XML::RelaxNG.parse(schema_source)
+        rescue ::Leptris::XML::Error => e
+          raise Moxml::ValidationError.new(
+            "RELAX NG schema parse failed: #{e.message}",
+          )
+        end
+
+        def relaxng_compile_file(path)
+          unless RELAXNG_SUPPORTED
+            raise Moxml::NotImplementedError,
+                  "RELAX NG validation requires a leptris binding with the RNG face"
+          end
+
+          ::Leptris::XML::RelaxNG.parse_file(path)
+        rescue ::Leptris::XML::Error => e
+          raise Moxml::ValidationError.new(
+            "RELAX NG schema parse failed: #{e.message}",
+          )
+        end
+
+        def relaxng_validate_errors(handle, document)
+          handle.validate_errors(to_binding(document))
+        end
+
+        def relaxng_valid?(handle, document)
+          handle.valid?(to_binding(document))
+        end
+
         def xsd_builtin_valid?(builtin, lexical)
           unless XSD_SUPPORTED
             raise Moxml::NotImplementedError,
@@ -579,6 +630,21 @@ module Moxml
                 bearing
               end
 
+              # The resolved verdict plus its generation stamp; the
+              # prewrapped traversal hands it down the tree so a fresh
+              # child skips its own document climb.
+              def doc_entity_stamp
+                doc_entity_bearing?
+                @doc_entity_stamp
+              end
+
+              def inherit_document_state(parent)
+                # The parent's own children call resolved the
+                # document-level verdict for this generation, and
+                # parent and child share the document.
+                @doc_entity_stamp = parent.doc_entity_stamp
+              end
+
               def [](key)
                 if key.is_a?(String) && !key.include?(":")
                   value = attr_read(key)
@@ -650,12 +716,17 @@ module Moxml
             if NN.method_defined?(:children_read)
               module ChildReads
                 def children
-                  @children = nil if @children_gen != context.children_generation
-                  @children_gen = context.children_generation
+                  ctx = @context || context
+                  generation = ctx.children_generation
+                  if @children_gen != generation
+                    @children = nil
+                    @children_gen = generation
+                  end
                   @children ||= if doc_entity_bearing?
                                   super
                                 else
-                                  NodeSet.new(children_read, context, self)
+                                  NodeSet.new(children_read, ctx, self,
+                                              prewrapped: true)
                                 end
                 end
               end
@@ -1115,6 +1186,72 @@ module Moxml
           @attachments ||= Moxml::NativeAttachment.new
         end
 
+        # --- engine XPath index guard ---------------------------------
+        # Sibling insertions do not invalidate the engine's document
+        # index that the node-set XPath lane uses, so after one the
+        # lane answers stale results (the tree and the first-only
+        # entry are correct; upstream bug filed). Track the state per
+        # binding document and route XPath to the reference Ruby
+        # engine until a child insertion rebuilds the engine index.
+        #
+        # FIXED upstream in libleptris 1.9.378 (leptris/leptris#1802):
+        # every splice path invalidates the index, so the guard is
+        # dead weight on modern engines — and it sat on the builder
+        # hot path (one Monitor-synchronized attachment set plus a
+        # document hop per add_child). Retirement is probed, not
+        # version-gated: any build that passes the #519 repro opts
+        # itself out, no moxml release needed.
+        XPATH_INDEX_STALE = :xpath_index_stale
+
+        def mark_xpath_index_stale(node)
+          return if native_xpath_index_fixed?
+
+          doc = xpath_index_document(node)
+          attachments.set(doc, XPATH_INDEX_STALE, true) if doc
+        end
+
+        def clear_xpath_index_stale(node)
+          return if native_xpath_index_fixed?
+
+          doc = xpath_index_document(node)
+          attachments.set(doc, XPATH_INDEX_STALE, false) if doc
+        end
+
+        def xpath_index_stale?(doc)
+          # leptris-ruby#519 is fixed upstream: on builds whose
+          # node-set index survives sibling insertion the stale mark
+          # is moot, and post-insert XPath stays on the native lane.
+          return false if native_xpath_index_fixed?
+
+          doc && attachments.get(doc, XPATH_INDEX_STALE)
+        end
+
+        # Runs the #519 repro once at the binding level: populate the
+        # node-set index, insert a sibling, and require the re-query
+        # to see the inserted element. True on fixed builds, so the
+        # guard auto-retires without a moxml release.
+        def native_xpath_index_fixed?
+          return @native_xpath_index_fixed unless @native_xpath_index_fixed.nil?
+
+          @native_xpath_index_fixed = begin
+            native_doc = ::Leptris::XML::Document.parse("<r><a/><b/></r>")
+            root = native_doc.root
+            root.xpath("child::*")
+            b = root.children.to_a[1]
+            b.add_previous_sibling(native_doc.create_element("c"))
+            names = root.xpath("child::*").to_a.map { |n| n.name.to_s }
+            names == %w[a c b]
+          rescue StandardError
+            false
+          end
+        end
+
+        def xpath_index_document(node)
+          return node if node.is_a?(::Leptris::XML::Document)
+
+          node.document
+        end
+
         def set_root(doc, element)
           to_binding(doc).root = to_binding(element)
         end
@@ -1135,13 +1272,23 @@ module Moxml
           true
         end
 
+        # Canonical XML excludes the initial whitespace of PI data;
+        # the C canonicalizer keeps the raw separator when the source
+        # used more than one whitespace character, so collapse it to
+        # the single canonical space (libxml2 oracle). In canonical
+        # output a literal "<?" can only start a PI: "<" is escaped in
+        # text and attribute values, and comments/DTD are not emitted
+        # on this lane.
+        NATIVE_C14N_PI_SEPARATOR = /<\?([^\s?]+)[ \t\r\n]+/
+
         def native_inclusive10(native)
           return nil unless native_c14n_byte_safe?
 
-          to_binding(native).canonicalize(
+          canonical = to_binding(native).canonicalize(
             ::Leptris::XML::FFI::C14N_1_0, nil,
             mode: ::Leptris::XML::FFI::C14N_MODE_CANONICAL
           )
+          canonical.gsub(NATIVE_C14N_PI_SEPARATOR, '<?\1 ')
         end
 
         def expanded_attr_value(element, uri, local)
@@ -1184,6 +1331,14 @@ module Moxml
           true
         end
 
+        # Our at_xpath falls back to the model's Ruby engine when the
+        # native lane answers nothing — the engine's node-set XPath
+        # index is stale after sibling insertion, so `at` must not be
+        # routed through the node-set lane.
+        def native_at_xpath?
+          true
+        end
+
         # UTF-8 is the default effective encoding; a prolog declaring
         # another encoding hands byte validity to that encoding's lane.
         DECLARED_ENCODING_RE =
@@ -1619,6 +1774,23 @@ module Moxml
           (owner_doc || create_document).create_element(name.to_s)
         end
 
+        # MINT_PRIMED: the compiled ext's create_element takes
+        # optional (context, adapter) and pre-writes the contract
+        # ivars in C — arity -1 vs the old 2. Self-gating: no
+        # version floor, the probe reads the loaded ext.
+        MINT_PRIMED = defined?(::Leptris::XML::NativeNode) &&
+          ::Leptris::XML::NativeNode
+            .method(:create_element).arity == -1
+
+        def mints_primed?
+          MINT_PRIMED
+        end
+
+        def create_primed_element(name, owner_doc:, context:, adapter:)
+          validate_element_name(name)
+          owner_doc.native_create_element(name.to_s, context, adapter)
+        end
+
         def create_native_text(content, owner_doc = nil)
           if NATIVE_MUTATIONS_COHERENT && owner_doc
             return owner_doc.native_create_text(content)
@@ -2265,6 +2437,7 @@ module Moxml
         # callers fall back to create_element + set_attribute +
         # add_child when absent.
         def create_element_with_attrs(parent, name, attrs)
+          validate_element_name(name)
           binding_parent = to_binding(parent)
           doc = binding_parent.document or return nil
           return nil unless ::Leptris::XML::Native.respond_to?(:create_element_with_attrs)
@@ -2600,6 +2773,15 @@ module Moxml
         end
 
         def add_child(parent, child)
+          result = add_child_impl(parent, child)
+          # A successful child insertion rebuilds the engine's
+          # document index; the upstream sibling-insert bug leaves it
+          # stale (see native_xpath), so a rebuild clears the guard.
+          clear_xpath_index_stale(parent) if result
+          result
+        end
+
+        def add_child_impl(parent, child)
           # Same-document Identity append — the builder hot path. One
           # document pair decides the verdict: the pin, the absorb
           # checks and the binding bridges only exist for
@@ -2712,6 +2894,12 @@ module Moxml
         end
 
         def add_previous_sibling(node, new_node)
+          result = add_previous_sibling_impl(node, new_node)
+          mark_xpath_index_stale(node)
+          result
+        end
+
+        def add_previous_sibling_impl(node, new_node)
           if NATIVE_READ_LAYER
             node = to_binding(node)
             new_node = to_binding(new_node)
@@ -2752,6 +2940,12 @@ module Moxml
         end
 
         def add_next_sibling(node, new_node)
+          result = add_next_sibling_impl(node, new_node)
+          mark_xpath_index_stale(node)
+          result
+        end
+
+        def add_next_sibling_impl(node, new_node)
           if NATIVE_READ_LAYER
             node = to_binding(node)
             new_node = to_binding(new_node)
@@ -2965,7 +3159,44 @@ module Moxml
           end.join
         end
 
+        # SET_TEXT_NATIVE: bindings with the unshadowed C alias
+        # (the add_child_native pattern — set_text_native aliases
+        # content= on the TypedData self) take the one-frame write:
+        # no doc_for climb, no address read, no module dispatch.
+        # Self-gating by respond_to? — older exts fall through to
+        # the set_binding_text face.
+        SET_TEXT_NATIVE = defined?(::Leptris::XML::NativeNode) &&
+          ::Leptris::XML::NativeNode.method_defined?(:set_text_native)
+
         def set_text_content(node, content)
+          if SET_TEXT_NATIVE && node.is_a?(::Leptris::XML::NativeNode)
+            begin
+              node.set_text_native(content.to_s)
+              return
+            rescue ::Leptris::XML::Error => e
+              # Same #401 contract as the fallback below: a detached
+              # (parentless) node re-raises as the named Moxml::Error.
+              raise if node.parent
+
+              raise Moxml::Error,
+                    "cannot set text content on a detached " \
+                    "(parentless) node — attach it to a document " \
+                    "first (issue #401): #{e.message}"
+            end
+          end
+
+          # Native-layer fast path (leptris-ruby#460): the C setter
+          # takes document+address directly — no binding twin mint
+          # per write. The Identity wrapper's own content= would
+          # re-enter the facade, so call the module face.
+          if NATIVE_SET_BINDING_TEXT && node.is_a?(::Leptris::XML::NativeNode) &&
+              (doc = doc_for(node))
+            ::Leptris::XML::Native.set_binding_text(
+              doc, node.address, content.to_s
+            )
+            return
+          end
+
           node = to_binding(node) if NATIVE_READ_LAYER
           case node
           when ::Leptris::XML::Document
@@ -3185,6 +3416,9 @@ module Moxml
             ::Leptris::XML::XPath.compile(expression)
           end
           document = node.is_a?(::Leptris::XML::Document) ? node : node.document
+          # A sibling insertion left the engine index stale; the
+          # reference engine walks the live tree (see the guard above).
+          return nil if xpath_index_stale?(document)
 
           if namespaces && !namespaces.empty?
             # Namespace-bound evaluation has no raw-pointer entry —

data/lib/moxml/adapter/libxml.rb

@@ -87,6 +87,10 @@ module Moxml
           false
         end
 
+        def add_sibling_returns_inserted?
+          true
+        end
+
         # Linear DOCTYPE prolog scanner. Returns
         # {name:, external_id:, system_id:, internal_subset:} or nil.
         # Single pass, quote- and bracket-aware: no backtracking, so
@@ -780,7 +784,8 @@ module Moxml
           return unless node && sibling
 
           native_node = unpatch_node(node)
-          native_sibling = unpatch_node(sibling)
+          native_sibling = import_for_attachment(native_node,
+                                                 unpatch_node(sibling))
 
           # Special handling for document-level processing instructions
           # When adding a PI as sibling to root element, store it on document
@@ -794,14 +799,35 @@ module Moxml
           end
 
           native_node.prev = native_sibling
+          native_sibling
         end
 
         def add_next_sibling(node, sibling)
           return unless node && sibling
 
           native_node = unpatch_node(node)
-          native_sibling = unpatch_node(sibling)
+          native_sibling = import_for_attachment(native_node,
+                                                 unpatch_node(sibling))
           native_node.next = native_sibling
+          native_sibling
+        end
+
+        # A markup fragment parsed by the facade lives in its own
+        # document; libxml refuses cross-document attachment. Import
+        # (deep-copy) into the target document and hand back the copy —
+        # the caller refreshes its wrapper to this native.
+        def import_for_attachment(native_node, native_sibling)
+          return native_sibling unless
+            native_node.is_a?(::LibXML::XML::Node) &&
+              native_sibling.is_a?(::LibXML::XML::Node)
+
+          target = native_node.doc
+          return native_sibling if target.nil?
+
+          source = native_sibling.doc
+          return native_sibling if source.equal?(target)
+
+          target.import(native_sibling)
         end
 
         def remove(node)
@@ -1066,6 +1092,12 @@ module Moxml
           native_node = unpatch_node(node)
           return [] unless native_node
 
+          if empty_default_namespace_binding?(namespaces)
+            return Moxml::XPath.evaluate_natives(native_node, expression,
+                                                namespaces,
+                                                adapter: :libxml)
+          end
+
           # libxml-ruby's Document#find returns EMPTY for relative
           # paths (nokogiri/libxml2 evaluate them fine): a relative
           # expression from the document node is equivalent to the

data/lib/moxml/adapter/nokogiri.rb

@@ -58,6 +58,10 @@ module Moxml
           true
         end
 
+        def element_indent_supported?
+          true
+        end
+
         # --- XSLT (Moxml::XSLT contract, libxslt-backed) ---
 
         def xslt_compile(sheet_source)
@@ -646,6 +650,12 @@ module Moxml
         end
 
         def xpath(node, expression, namespaces = nil)
+          if empty_default_namespace_binding?(namespaces)
+            return Moxml::XPath.evaluate_natives(node, expression,
+                                                 namespaces,
+                                                 adapter: :nokogiri)
+          end
+
           # An explicit bindings hash — even EMPTY — makes nokogiri
           # register a prefix context, which disables libxml2's
           # literal xmlns: default-namespace handling. Only pass the

data/lib/moxml/adapter/oga.rb

@@ -28,8 +28,23 @@ module Moxml
           doc.children << element
         end
 
+        # The UTF-8 BOM is an encoding signature, not content (model,
+        # Parsing); Oga otherwise leaves it in the tree as a
+        # document-level text node.
+        def strip_bom(xml)
+          return xml unless xml.is_a?(String)
+
+          if defined?(Encoding) && xml.encoding == Encoding::BINARY
+            xml.byteslice(0, 3) == "\xEF\xBB\xBF".b ? xml.byteslice(3..) : xml
+          elsif xml.start_with?("")
+            xml[1..]
+          else
+            xml
+          end
+        end
+
         def parse(xml, options = {}, _context = nil)
-          processed_xml = preprocess_entities(xml)
+          processed_xml = strip_bom(preprocess_entities(xml))
 
           native_doc = begin
             ::Oga.parse_xml(processed_xml, strict: options[:strict])
@@ -203,7 +218,15 @@ module Moxml
 
         def namespace(element)
           case element
-          when ::Oga::XML::Element, ::Oga::XML::Attribute
+          when ::Oga::XML::Attribute
+            # Unprefixed attributes are in no namespace, always
+            # (Namespaces 1.0 §5.2). Oga resolves them against the
+            # element's default namespace, which is wrong and makes
+            # bare-name reads miss under a default namespace.
+            return nil if element.namespace_name.nil?
+
+            element.namespace
+          when ::Oga::XML::Element
             element.namespace
           end
         rescue NoMethodError
@@ -247,10 +270,10 @@ module Moxml
         def children(node, **_entity_bearing)
           all_children = []
 
-          if node.is_a?(::Oga::XML::Document)
-            all_children += [node.xml_declaration,
-                             node.doctype].compact
-          end
+          # The XML declaration is document state, not a child node
+          # (model, Object model): it never appears in children listings.
+          # The doctype follows the Nokogiri contract and is listed.
+          all_children << node.doctype if node.is_a?(::Oga::XML::Document) && node.doctype
 
           return all_children unless node.is_a?(::Oga::XML::Node) || node.is_a?(::Oga::XML::Document)
 
@@ -513,7 +536,7 @@ module Moxml
         def processing_instruction_content(node)
           # Oga keeps the target/content separator space inside the
           # PI's text; the model's content is the data AFTER the
-          # separator (D-04). Separator whitespace is parser syntax, and
+          # separator. Separator whitespace is parser syntax, and
           # leaving it in makes canonicalization non-idempotent (the
           # serializer re-adds the separator each round — TODO.sota/02,
           # M2).
@@ -565,6 +588,15 @@ module Moxml
         end
 
         def xpath(node, expression, namespaces = nil)
+          # oga's engine has no xmlns: default-namespace idiom
+          # (D-01); the reference engine implements it (model,
+          # Names and namespaces).
+          if expression.include?("xmlns:")
+            return Moxml::XPath.evaluate_natives(
+              node, expression, namespaces || {}, adapter: :oga
+            )
+          end
+
           result = node.xpath(expression, {},
                               namespaces: namespaces&.transform_keys(&:to_s))
           # Adapter contract: Array<native> | scalar. Oga's engine

data/lib/moxml/adapter/ox.rb

@@ -108,6 +108,14 @@ module Moxml
           end
         end
 
+        # Ox's SAX parser reports text only: CDATA, comments and PIs
+        # are folded into text or dropped (D-10). Subscribing to those
+        # families raises the named error instead of silently answering
+        # an incomplete stream.
+        def sax_event_family_supported?(family)
+          !%i[cdata comment processing_instruction].include?(family)
+        end
+
         def create_document(native_doc = nil)
           attrs = native_doc&.attributes || {}
           ::Ox::Document.new(**attrs)

data/lib/moxml/adapter/rexml.rb

@@ -22,6 +22,10 @@ module Moxml
           true
         end
 
+        def element_indent_supported?
+          true
+        end
+
         def parse(xml, options = {}, _context = nil)
           xml = "" if xml.nil?
 
@@ -215,8 +219,10 @@ module Moxml
         def children(node, **_entity_bearing)
           return [] unless node.is_a?(::REXML::Parent)
 
-          # Return all children preserving whitespace text nodes
-          result = node.children.dup
+          # Return all children preserving whitespace text nodes. The XML
+          # declaration is document state, not a child node (model,
+          # Object model), so it is never listed.
+          result = node.children.grep_v(::REXML::XMLDecl)
 
           # Include any EntityReference wrappers stored alongside native
           # children. Native children are identity-unique; only this
@@ -636,6 +642,15 @@ module Moxml
         end
 
         def xpath(node, expression, namespaces = {})
+          # REXML's engine answers no text nodes for text() node
+          # tests (D-07, both axes); the reference engine does
+          # (model, XPath evaluation).
+          if expression.match?(/\btext\s*\(/)
+            return Moxml::XPath.evaluate_natives(
+              node, expression, namespaces || {}, adapter: :rexml
+            )
+          end
+
           # XPath.match for every expression: get_elements only
           # handles simple child-name paths — attribute terminals,
           # absolute paths and predicates silently degrade there.

data/lib/moxml/attribute_resolver.rb

@@ -109,6 +109,10 @@ module Moxml
       # over-invalidate (global bump instead of local) — a no-op
       # for correctness.
       if name.start_with?("xmlns")
+        # Introducing (or rewriting) a namespace declaration: mark the
+        # context BEFORE the invalidation, so this write's generation
+        # bump fans out to every wrapper's memoized scope reads.
+        element.context.mark_namespaces_active!
         adapter.set_attribute(element.native, name, value)
         element.invalidate_attribute_cache!
         return value

data/lib/moxml/c14n/data_model.rb

@@ -115,6 +115,14 @@ module Moxml
           seen_root = false
           idx = 0
           document.children.each do |child|
+            # Whitespace between document-level nodes is not part of
+            # the canonical form (C14N §2.1 renders the document
+            # element and the PIs/comments outside it only). rexml
+            # retains such text nodes at parse (D-15); every engine's
+            # form must still exclude them.
+            next if child.is_a?(::Moxml::Text) ||
+              child.is_a?(::Moxml::Cdata)
+
             if child.is_a?(::Moxml::Element)
               next if seen_root
 

data/lib/moxml/c14n/processor.rb

@@ -21,6 +21,11 @@ module Moxml
       def process(root_node)
         output = (+"")
         process_node(root_node, output)
+        # Document-level PI/comment rendering uses a newline as a
+        # SEPARATOR between nodes (and around the root), not as a
+        # leading/trailing pad: the canonical form starts and ends
+        # with the first/last node itself (libxml2 oracle).
+        output.chomp! if root_node.node_type == :root
         output
       end
 
@@ -93,26 +98,30 @@ module Moxml
         return unless with_comments
         return unless node.in_node_set?
 
-        # Comment outside the document element gets a line break before/after
-        # to keep canonical output readable.
-        if parent_element.nil? && output.length.positive?
-          output << "\n"
-        end
+        ensure_separator(output) if parent_element.nil?
         output << "<!--" << node.value << "-->"
         output << "\n" if parent_element.nil?
       end
 
       def process_pi_node(node, output, parent_element)
         return unless node.in_node_set?
+        # C14N never emits the XML declaration; the "xml" target is
+        # reserved and cannot appear as a PI in a well-formed document.
+        return if node.target.to_s.casecmp("xml").zero?
 
-        if parent_element.nil? && output.length.positive?
-          output << "\n"
-        end
+        ensure_separator(output) if parent_element.nil?
         output << "<?" << node.target
         output << " " << node.data unless node.data.to_s.empty?
         output << "?>"
         output << "\n" if parent_element.nil?
       end
+
+      # One newline between document-level nodes, never a doubled
+      # separator (a PI's trailing newline already starts the next
+      # node's line).
+      def ensure_separator(output)
+        output << "\n" if output.length.positive? && !output.end_with?("\n")
+      end
     end
   end
 end