moxml 0.5.101 → 0.5.103

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9109c62e1dc81916376846aa35756d02e7caa0caedbf96937c6c89fb99687389
-  data.tar.gz: cab100fc1e408a0c511d330c81bc5f2b71e8dc0f6fa30e2c1b7a7e094d1c81a1
+  metadata.gz: 566f2842eac4e01753965cb5f56eada53d6683b3ef6b576015eb4b0da572ae67
+  data.tar.gz: ccc15ef083358a018e1536983017c6681c70c11ccbb4678ac123e5b0b2c9aada
 SHA512:
-  metadata.gz: d041b4af64d6fe7d0d87d129ce35053da5405ba23b866e7dd3ef8c7237a21b73ff60d9baefafacf39781d5691e44b95ec295fcfe9eb54fa5e2a091ed01ea6ab7
-  data.tar.gz: 2f21edaf882c65e3229c617eb5df04e49b0198de3133d968e898fa9ec9218d34b52c5f165791804aafb328bae55db20fddc80c0976d596c686e66630bbd0293d
+  metadata.gz: 2c29296b60bedabbc512c9f5c454b0195b3632dbf9952b0c397fc3bad6554135dd3096a04a34e1abddf9ce40088af4856b2ead7d8ca69a4eb251dc3db38286b3
+  data.tar.gz: fd1684a85d2ace2191b33bf996a12e8bea6cb535a340732cccee3318abc6649ba2e07548509d1469959e10ee711ecec650f8ec6b4525beb6a66e2c9a75a81c1d

data/.github/workflows/dependent-tests.yml

@@ -13,6 +13,13 @@ on:
   repository_dispatch:
     types: [ release-passed ]
 
+# One live run per workflow+event+ref: a superseded push to the
+# same PR/branch cancels its predecessors instead of queueing
+# behind them (the runner queue otherwise stacks generations).
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: true
+
 jobs:
   rake:
     uses: metanorma/ci/.github/workflows/dependent-rake.yml@main

data/.github/workflows/opal.yml

@@ -6,6 +6,13 @@ on:
     tags: [ v* ]
   pull_request:
 
+# One live run per workflow+event+ref: a superseded push to the
+# same PR/branch cancels its predecessors instead of queueing
+# behind them (the runner queue otherwise stacks generations).
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: true
+
 permissions:
   contents: read
 

data/.github/workflows/rake.yml

@@ -6,6 +6,13 @@ on:
     tags: [ v* ]
   pull_request:
 
+# One live run per workflow+event+ref: a superseded push to the
+# same PR/branch cancels its predecessors instead of queueing
+# behind them (the runner queue otherwise stacks generations).
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: true
+
 permissions:
   contents: read
 

data/.github/workflows/round-trip.yml

@@ -5,6 +5,13 @@ on:
     branches: [ main ]
   pull_request:
 
+# One live run per workflow+event+ref: a superseded push to the
+# same PR/branch cancels its predecessors instead of queueing
+# behind them (the runner queue otherwise stacks generations).
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: true
+
 permissions:
   contents: read
 

data/.github/workflows/windows.yml

@@ -6,6 +6,13 @@ on:
   pull_request:
   workflow_dispatch:
 
+# One live run per workflow+event+ref: a superseded push to the
+# same PR/branch cancels its predecessors instead of queueing
+# behind them (the runner queue otherwise stacks generations).
+concurrency:
+  group: ${{ github.workflow }}-${{ github.event_name }}-${{ github.ref }}
+  cancel-in-progress: true
+
 permissions:
   contents: read
 

data/lib/moxml/adapter/base.rb

@@ -47,8 +47,11 @@ module Moxml
 
         def parse_fragment(xml, _context = nil)
           doc = parse("<m>#{xml}</m>")
-          root = root(doc)
-          root ? children(root) : []
+          # doc.root is a wrapper (adapter root overrides answer
+          # patched/unpatched natives indifferently); children() and
+          # every adapter below expect natives.
+          root_node = doc.root
+          root_node ? children(root_node.native) : []
         end
 
         # Streaming incremental parse (leptris engine): yields each
@@ -154,6 +157,14 @@ module Moxml
           node
         end
 
+        # Element-only children: adapters whose engine carries the
+        # face override (leptris C filter, nokogiri native); the
+        # default type-filters the native child list so non-element
+        # wrappers never mint on element-only traversals.
+        def element_children(node)
+          children(node).select { |child| node_type(child) == :element }
+        end
+
         # Prefixed-attribute value fast path: adapters whose engine
         # resolves expanded-name (uri, local) lookups natively answer
         # the value here; others fall back to the resolver's
@@ -394,6 +405,13 @@ namespace_validation_mode: :strict)
           true
         end
 
+        # Serialization of the node's children (Element#inner_xml).
+        # Built over the children/serialize contract; adapters with a
+        # native inner-serialization face may override.
+        def inner_xml(node)
+          children(node).map { |child| serialize(child) }.join
+        end
+
         # Whether the engine offers a bulk materialization path for
         # Materializer (issue #132). When true, the adapter gets
         # #materialize_fields(native, buffers, &block) — fill the

data/lib/moxml/adapter/leptris.rb

@@ -100,6 +100,10 @@ module Moxml
         NN_NEXT_SIBLING = NN.instance_method(:next_sibling)
         NN_CONTENT = NN.instance_method(:content)
         NN_CHILDREN = NN.instance_method(:children)
+        # The C element filter — captured because ElementBehavior's
+        # element_children alias shadows the face on Identity natives
+        # (a plain dispatch would recurse into the wrapper method).
+        NN_ELEMENT_CHILDREN = NN.instance_method(:element_children)
         NN_NODE_TYPE = NN.instance_method(:node_type)
         NN_DOCUMENT = NN.instance_method(:document)
         NN_ADD_CHILD = NN.instance_method(:add_child)
@@ -503,7 +507,37 @@ module Moxml
         raise Moxml::XsltError, "stylesheet compile failed: #{e.message}"
       end
 
+      # Bindings >= 1.9.290.0 thread top-level xsl:param overrides
+      # (leptris#1478); older bindings raise the typed error (the
+      # #360 face gap, face-probed so a misrelease degrades instead
+      # of NoMethodError-ing — the 1.9.199.0 lesson).
+      NATIVE_XSLT_PARAMS =
+        NATIVE_READ_LAYER &&
+        Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.290.0") &&
+        ::Leptris::XML::XSLT::Stylesheet.instance_method(:apply_to)
+          .parameters.size > 1
+
+      # The seam contract passes the libxslt flat quoted array; the
+      # binding wants the raw name => value hash (leptris#1478
+      # matches nokogiri's quoted-string semantics internally).
+      def self.flat_params_to_hash(params)
+        return params if params.is_a?(Hash)
+        return {} if params.nil? || params.empty?
+
+        params.each_slice(2).to_h { |name, value| [name, unquote_param(value)] }
+      end
+
+      def self.unquote_param(value)
+        str = value.to_s
+        str.start_with?("'") && str.end_with?("'") && str.length >= 2 ? str[1..-2] : str
+      end
+
       def self.xslt_apply_document(sheet, document_native, params)
+        if NATIVE_XSLT_PARAMS
+          return sheet.apply_to(document_native,
+                                params: flat_params_to_hash(params))
+        end
+
         assert_xslt_no_params(params)
         sheet.apply_to(document_native)
       rescue ::Leptris::XML::XPathError => e
@@ -511,6 +545,11 @@ module Moxml
       end
 
       def self.xslt_apply_string(sheet, document_native, params)
+        if NATIVE_XSLT_PARAMS
+          return sheet.serialize(document_native,
+                                 params: flat_params_to_hash(params))
+        end
+
         assert_xslt_no_params(params)
         sheet.serialize(document_native)
       rescue ::Leptris::XML::XPathError => e
@@ -521,8 +560,9 @@ module Moxml
         return if params.nil? || params.empty?
 
         raise Moxml::XsltError,
-              "XSLT params are not threaded by the leptris engine yet " \
-              "(leptris-ruby#360); pass an empty params hash"
+              "XSLT params are not threaded by this binding " \
+              "(leptris-ruby#360); upgrade to leptris >= 1.9.290.0 or " \
+              "pass an empty params hash"
       end
 
       def self.native_c14n_byte_safe?
@@ -1397,6 +1437,19 @@ module Moxml
           end
         end
 
+        # Element-only children through the engine-level filter: the
+        # C face mints element-kind natives directly (klass-children),
+        # so interleaved text/comment nodes cost nothing. Entity
+        # markers are text-kind — the element filter excludes them by
+        # construction, no marker split needed.
+        def element_children(node)
+          if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
+            return NN_ELEMENT_CHILDREN.bind_call(node).to_a
+          end
+
+          to_binding(node).element_children
+        end
+
         def children(node, entity_bearing: false)
           # NATIVE_READ_LAYER gates the whole keep-path: it consults
           # NN_DOCUMENT (defined only with the native layer), and
@@ -1596,10 +1649,25 @@ module Moxml
           [copied, pointers]
         end
 
-        # The binding reports the root element as parentless; the
-        # moxml contract roots at the document.
+        # The binding reports the root element and the document-level
+        # parts as parentless; the moxml contract roots them at the
+        # document. DocType carries no #parent at all (plain
+        # c_ptr+document value object) and a parentless PI is a
+        # document-level one by construction — in-tree parts have
+        # element parents.
         def root_parent(node)
-          node.parent || (node.document&.root == node ? node.document : nil)
+          return node.document if node.is_a?(::Leptris::XML::DocType)
+
+          parent = node.parent
+          return parent if parent
+
+          doc = node.document
+          return nil unless doc
+
+          return doc if doc.root == node ||
+            node.is_a?(::Leptris::XML::ProcessingInstruction)
+
+          nil
         end
 
         def next_sibling(node)
@@ -1949,7 +2017,19 @@ module Moxml
             node = to_binding(node)
             new_node = to_binding(new_node)
           end
-          return node.replace(new_node) if node.is_a?(::Leptris::XML::Element)
+          if node.is_a?(::Leptris::XML::Element)
+            # NOT Element#replace: it detaches via
+            # leptris_element_remove_child, which leaves the replaced
+            # node's sibling links pointing into the live tree. A later
+            # append of that node splices the stale run under the new
+            # parent, and when the run contains the append target the
+            # tree cycles (standoc term cleanup does
+            # t << n.replace(t2)). Insert + unlink instead: the unlink
+            # path clears the sibling links.
+            node.add_next_sibling(new_node)
+            node.unlink
+            return new_node
+          end
 
           # libleptris only offers element-anchored insertion, so a
           # content node (text/comment/CDATA/PI) is replaced by
@@ -1972,11 +2052,23 @@ module Moxml
           new_node
         end
 
+        NATIVE_APPEND_CHILDREN =
+          NATIVE_READ_LAYER &&
+          Gem::Version.new(::Leptris::VERSION) >= Gem::Version.new("1.9.290.0")
+
         def replace_children(node, new_children)
           if NATIVE_READ_LAYER
             node = to_binding(node)
             new_children = new_children.map { |child| to_binding(child) }
           end
+          if NATIVE_APPEND_CHILDREN && !new_children.empty?
+            # One crossing to clear, one to append N (leptris-ruby#366's
+            # bulk face; the old path paid an append crossing per child).
+            ::Leptris::XML::FFI.check_status(
+              ::Leptris::XML::FFI.leptris_element_remove_children(node.c_ptr),
+            )
+            return node.append_children(new_children)
+          end
           node.children = new_children
         end
 
@@ -2175,7 +2267,22 @@ module Moxml
             node = to_binding(node)
           end
           return nil unless native_context_node?(node)
-          return nil unless native_expression?(expression)
+          # Hash-bound xmlns rides native on probing bindings
+          # (leptris resolves the reserved prefix from the hash);
+          # empty mappings (xmlns="") select no-namespace elements
+          # and stay on the Ruby engine — the C pairs-set rejects
+          # empty URIs. Everything else keeps the expression-keyed
+          # gate.
+          return nil unless (namespaces.is_a?(Hash) &&
+                             namespaces["xmlns"].to_s.length.positive? &&
+                             xmlns_native?) ||
+            native_expression?(expression)
+          # The leptris engine mishandles namespace-prefixed node
+          # tests: "m:*" matches elements in ANY namespace and
+          # "m:name" matches none, regardless of the binding. Route
+          # namespace-bound queries to the Ruby engine until the
+          # engine grows correct prefix resolution.
+          return nil if namespaces && !namespaces.empty?
           # 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.
@@ -2311,6 +2418,28 @@ module Moxml
         # xmlns:name is a nokogiri-compat convention addressing
         # elements in the default namespace; only the Ruby engine
         # implements it.
+        # One-time capability probe: does the binding's native engine
+        # resolve the reserved xmlns prefix from the namespace hash?
+        # Memoized class-level — the answer never changes for an
+        # install. Only hash-bound xmlns queries may ride native
+        # (the gate below is expression-keyed and cannot see the
+        # call's namespaces); unbound xmlns stays on the Ruby engine,
+        # whose reserved-prefix branch matches default-namespace
+        # elements.
+        def xmlns_native?
+          return @xmlns_native unless @xmlns_native.nil?
+
+          @xmlns_native = begin
+            probe = parse('<r xmlns="urn:p"><a>1</a></r>', {}, nil)
+            raw = to_binding(probe.root.native)
+            res = raw.xpath("./xmlns:a", { "xmlns" => "urn:p" })
+            list = res.respond_to?(:to_a) ? res.to_a : [res].compact
+            list.size == 1 && list.first.text.to_s == "1"
+          rescue StandardError
+            false
+          end
+        end
+
         def uses_xmlns_prefix?(ast)
           return true if ast.type == :test && ast.value[:namespace] == "xmlns"
 

data/lib/moxml/adapter/libxml.rb

@@ -1099,8 +1099,9 @@ module Moxml
             target_doc = doc || (element.is_a?(::LibXML::XML::Node) ? element.doc : nil)
 
             if target_doc
-              # Use deep import to ensure all descendants are included
-              imported = target_doc.import(child, true)
+              # libxml-ruby 6.0 dropped import's deep flag; the import
+              # walks the subtree either way.
+              imported = target_doc.import(child)
               element << imported
             else
               # No target document - create a deep copy of the node instead

data/lib/moxml/adapter/nokogiri.rb

@@ -318,6 +318,10 @@ module Moxml
           node.children
         end
 
+        def element_children(node)
+          node.element_children
+        end
+
         def adjacent_to_entity_reference?(node)
           node.previous_sibling.is_a?(::Nokogiri::XML::EntityReference) ||
             node.next_sibling.is_a?(::Nokogiri::XML::EntityReference)

data/lib/moxml/document.rb

@@ -16,6 +16,38 @@ module Moxml
     end
 
     def root=(element)
+      owner = element.is_a?(Node) && element.document
+      # Only a genuinely ATTACHED foreign element adopts: the document
+      # face answers arbitrary Document wrappers for FLOATING elements
+      # (leptris: a stale mint-time document; ox: an Element), and
+      # adopting a floating element splices its (empty) copy as root —
+      # the caller keeps appending to the detached original and the
+      # tree serializes empty (lutaml-model's builder lost every
+      # child this way). Attached means parented, or another
+      # document's current root.
+      attached = !element.parent.nil? ||
+        (owner.is_a?(Document) && owner.root.equal?(element))
+      if owner.is_a?(Document) && attached &&
+          !owner.equal?(self) && element.context.equal?(context)
+        # libleptris refuses a root owned by another document (the
+        # engine's set_root ownership check), while Nokogiri adopts.
+        # Cross-document CHILD attaches are supported, so build the
+        # root here, mirror its declarations and attributes, and
+        # splice the foreign subtree child-by-child — each attach
+        # rides adapter add_child, which pins the owner document
+        # against GC (issue #304).
+        new_root = create_element(element.name)
+        element.attribute_pairs.each { |k, v| new_root[k] = v }
+        element.declared_namespaces.each do |prefix, uri|
+          new_root.add_namespace(prefix, uri)
+        end
+        adapter.set_root(@native, new_root.native)
+        new_root.parent_node = self
+        element.children.to_a.each { |child| new_root.add_child(child) }
+        context.bump_children_generation
+        invalidate_children_cache!
+        return
+      end
       adapter.set_root(@native, element.native)
       element.parent_node = self
       invalidate_children_cache!

data/lib/moxml/element.rb

@@ -159,6 +159,40 @@ module Moxml
       end
     end
 
+    # Nokogiri-compatible: delete(name) removes the attribute
+    def delete(name)
+      remove_attribute(name)
+    end
+
+    # Nokogiri-compatible: element-only children. The adapter seam
+    # filters at the engine level where the binding carries the face
+    # (leptris bulk element children, nokogiri native), so interleaved
+    # text/comment nodes never mint wrappers on hot traversals.
+    # Memo rides the children generation (#310's mutation clock).
+    def elements
+      @elements = nil if @elements_gen != context.children_generation
+      @elements_gen = context.children_generation
+      @elements ||= NodeSet.new(adapter.element_children(@native), context, self)
+    end
+    alias element_children elements
+
+    # Nokogiri-compatible: children= replaces the entire child list
+    def children=(node_or_nodes)
+      natives = case node_or_nodes
+                when String
+                  wrapper = "_moxml_children_#{Process.pid}_#{object_id}"
+                  context.parse("<#{wrapper}>#{node_or_nodes}</#{wrapper}>")
+                    .root.children.map(&:native)
+                when Moxml::Node then [node_or_nodes.native]
+                when Array, NodeSet then node_or_nodes.map(&:native)
+                else
+                  raise ArgumentError, "children= accepts String, Node, or Array"
+                end
+      adapter.replace_children(@native, natives)
+      context.bump_children_generation
+      invalidate_children_cache!
+    end
+
     def remove_attribute(name)
       # Both remove paths end in invalidate_attribute_cache!, which
       # bumps the generation.
@@ -233,6 +267,19 @@ module Moxml
       invalidate_namespace_cache!
     end
 
+    # Nokogiri-compatible: bind the element to +uri+ as its DEFAULT
+    # namespace — the name drops any prefix and the declaration lands
+    # on this element. Children keep their own bindings. Skip when an
+    # identical default namespace is already in scope: declaring again
+    # serializes a duplicate xmlns attribute. (add_namespace is the
+    # primitive: namespace=({nil => uri}) declares twice on leptris.)
+    def default_namespace=(uri)
+      self.name = name.split(":", 2)[-1] if name.to_s.include?(":")
+      return if namespace_prefix.to_s.empty? && namespace_uri.to_s == uri.to_s
+
+      add_namespace(nil, uri.to_s)
+    end
+
     # All namespaces IN SCOPE for this element — its own
     # declarations plus everything inherited from ancestors —
     # matching the Nokogiri #namespaces contract consumers port
@@ -296,6 +343,8 @@ module Moxml
       invalidate_children_cache!
     end
 
+    alias content= text=
+
     def inner_text
       text = raw_inner_text
       entity_bearing? ? adapter.restore_entities(text) : text

data/lib/moxml/node.rb

@@ -104,7 +104,104 @@ module Moxml
       Moxml::Node.wrap(adapter.previous_sibling(@native), context)
     end
 
+    # Nokogiri-compatible reader spellings.
+    alias next next_sibling
+    alias previous previous_sibling
+
+    # Nokogiri-compatible: nearest sibling elements, skipping text and
+    # comment nodes.
+    def next_element
+      s = next_sibling
+      s = s.next_sibling while s && !s.is_a?(Moxml::Element)
+      s
+    end
+
+    def previous_element
+      s = previous_sibling
+      s = s.previous_sibling while s && !s.is_a?(Moxml::Element)
+      s
+    end
+
+    # Nokogiri-compatible append sugar: node << appends. Strings
+    # parse as fragments (markup, not literal text).
+    def <<(node)
+      add_child(node)
+      self
+    end
+
+    # Nokogiri-compatible: reparent — node.parent = new_parent moves
+    # this node (removing it from its current tree) under the target.
+    def parent=(new_parent)
+      remove
+      new_parent.add_child(self)
+    end
+
+    # Insert ahead of the current first child (nokogiri-monkeypatch
+    # convention used across metanorma). Strings parse as fragments
+    # (the sibling_operand convention).
+    def add_first_child(node)
+      if first_child
+        first_child.add_previous_sibling(node)
+      else
+        add_child(node)
+      end
+      self
+    end
+
     def add_child(node)
+      # Nokogiri semantics: a String operand is MARKUP, parsed and
+      # appended (cleanup code inserts "<bibliography/>" style
+      # strings); the adapter path would mint a literal text node.
+      # Metanorma's Nokogiri returns the new children as a NodeSet
+      # for markup (misc.add_child("<UnitsML/>").first idiom), self
+      # for nodes.
+      if node.is_a?(String)
+        nodes = context.parse_fragment(node).to_a
+        nodes.each { |child| attach_child(child) }
+        return NodeSet.new(nodes.map(&:native), context)
+      end
+      attach_child(node)
+      self
+    end
+
+    def add_previous_sibling(node)
+      # String operands insert every fragment root; returns the new
+      # nodes as a NodeSet (metanorma idiom: sect.add_next_sibling(
+      # "<bibliography/>").first).
+      if node.is_a?(String)
+        nodes = context.parse_fragment(node).to_a
+        nodes.each { |n| attach_previous_sibling(n) }
+        return NodeSet.new(nodes.map(&:native), context)
+      end
+      attach_previous_sibling(node)
+      self
+    end
+
+    # Nokogiri-compatible assignment forms: node.next = / node.previous =.
+    # String operands are parsed as XML fragments, like Nokogiri.
+    def next=(node)
+      add_next_sibling(node)
+    end
+
+    def previous=(node)
+      add_previous_sibling(node)
+    end
+
+    def add_next_sibling(node)
+      if node.is_a?(String)
+        nodes = context.parse_fragment(node).to_a
+        anchor = self
+        nodes.each do |n|
+          attach_next_sibling_to(anchor, n)
+          anchor = n
+        end
+        return NodeSet.new(nodes.map(&:native), context)
+      end
+      attach_next_sibling_to(self, node)
+      self
+    end
+
+    def attach_child(node)
       context.bump_children_generation
       node = prepare_node(node)
       adapter.add_child(@native, node.native)
@@ -121,7 +218,7 @@ module Moxml
       self
     end
 
-    def add_previous_sibling(node)
+    def attach_previous_sibling(node)
       context.bump_children_generation
       node = prepare_node(node)
       adapter.add_previous_sibling(@native, node.native)
@@ -134,32 +231,26 @@ module Moxml
       self
     end
 
-    # Nokogiri-compatible assignment forms: node.next = / node.previous =.
-    # String operands are parsed as XML fragments, like Nokogiri.
-    def next=(node)
-      add_next_sibling(sibling_operand(node))
-    end
-
-    def previous=(node)
-      add_previous_sibling(sibling_operand(node))
-    end
-
-    def sibling_operand(node)
-      return node unless node.is_a?(String)
-
-      context.parse_fragment(node).first
-    end
-
-    def add_next_sibling(node)
+    def attach_next_sibling_to(anchor, node)
       context.bump_children_generation
       node = prepare_node(node)
-      adapter.add_next_sibling(@native, node.native)
-      parent&.invalidate_children_cache!
-      invalidate_parent_children_cache!
+      adapter.add_next_sibling(anchor.native, node.native)
+      anchor.parent&.invalidate_children_cache!
+      anchor.invalidate_parent_children_cache!
       self
     end
 
     def remove
+      # Nokogiri parity: unlinking an already-detached node is a
+      # no-op returning self. Re-attach idioms like
+      # `t << n.replace(x).remove` (standoc term cleanup) detach with
+      # #replace and rely on this; leptris would raise "Not found".
+      # The wrapper-side @parent_node link decides when present
+      # (add_child sets it); the adapter resolution covers
+      # link-less wrappers (at()-resolved nodes), whose parents are
+      # canonical since #313.
+      return self if @parent_node.nil? && parent.nil?
+
       context.bump_children_generation
       invalidate_parent_children_cache!
       adapter.remove(@native)
@@ -203,6 +294,18 @@ module Moxml
       result
     end
 
+    # Nokogiri-compatible: string interpolation of a node serializes
+    # it ("#{node}" in cleanup code), not Object#to_s.
+    def to_s
+      to_xml
+    end
+
+    # Nokogiri-compatible: to_str yields the text content (their C
+    # node_to_str; standoc does x.content = x.to_str on <script>).
+    def to_str
+      text
+    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
@@ -375,7 +478,15 @@ module Moxml
     # the document node.
     #
     # @return [NodeSet] ancestors ordered nearest-first
-    def ancestors
+    # Nokogiri-compatible: an element-name argument filters the set.
+    def ancestors(selector = nil)
+      all = _ancestors_all
+      return all unless selector
+
+      all.select { |a| a.name == selector.to_s }
+    end
+
+    def _ancestors_all
       return NodeSet.new([], context) if document?
 
       natives = []
@@ -439,18 +550,9 @@ module Moxml
     # elements share the same qualified name, keeping paths minimal.
     #
     # @return [String] XPath expression
-    # @raise [Moxml::NotImplementedError] for node types other than
-    #   element and document
     def path
       return "/" if document?
 
-      unless element?
-        raise Moxml::NotImplementedError.new(
-          "path is only supported for element and document nodes",
-          feature: "path",
-        )
-      end
-
       segments = []
       current = self
       while current && !current.document?
@@ -460,6 +562,19 @@ module Moxml
       "/#{segments.join('/')}"
     end
 
+    # The XPath node-test spelling for this non-element node.
+    def path_type_test
+      if text? || cdata?
+        "text()"
+      elsif comment?
+        "comment()"
+      elsif processing_instruction?
+        "processing-instruction()"
+      else
+        name.to_s
+      end
+    end
+
     # Returns the 1-based line number where this node appears in the
     # source XML, or nil when the underlying adapter does not track
     # source positions.
@@ -564,19 +679,25 @@ module Moxml
 
     private
 
-    # XPath segment for an element: the qualified name, plus a positional
-    # predicate only when same-named element siblings make it ambiguous.
-    def path_segment_for(element)
-      name = element.name
-      parent = element.parent
+    # XPath segment for a node: elements use their qualified name,
+    # other node kinds their XPath type test (text(), comment(), ...).
+    # A positional predicate is emitted only when same-kind siblings
+    # make the segment ambiguous.
+    def path_segment_for(node)
+      name = node.element? ? node.name : node.path_type_test
+      parent = node.parent
       return name unless parent
 
-      same_name = parent.children.select do |child|
-        child.element? && child.name == name
+      same_kind = parent.children.select do |child|
+        if node.element?
+          child.element? && child.name == name
+        else
+          !child.element? && child.path_type_test == name
+        end
       end
-      return name if same_name.size == 1
+      return name if same_kind.size == 1
 
-      "#{name}[#{same_name.find_index(element) + 1}]"
+      "#{name}[#{same_kind.find_index(node) + 1}]"
     end
 
     def prepare_node(node)

data/lib/moxml/node_set.rb

@@ -6,6 +6,15 @@ module Moxml
 
     attr_reader :context
 
+    # Nokogiri-compatible set difference: nodes in this set absent
+    # from the other, identity-compared on natives.
+    def -(other)
+      excluded = {}.compare_by_identity
+      other.native_nodes.each { |n| excluded[n] = true }
+      remaining = native_nodes.reject { |n| excluded.key?(n) }
+      self.class.new(remaining, @context, @parent_node)
+    end
+
     # nodes: Array of natives, or an adapter's LazyNodeSet — the
     # native set is held unmaterialized until an operation needs an
     # Array (#+, #<<, #delete, Range slices).
@@ -76,6 +85,23 @@ module Moxml
     end
     alias length size
 
+    # Nokogiri-compatible: serialize the set's members in order.
+    def to_xml(options = {})
+      map { |n| n.to_xml(options) }.join
+    end
+
+    # Nokogiri-compatible: string interpolation of a NodeSet
+    # serializes it ("#{nodes}" in cleanup code), not Object#to_s.
+    def to_s
+      to_xml
+    end
+
+    # Nokogiri-compatible: Array#flatten and multiple-assignment
+    # treat a NodeSet as its wrapped-element array via to_ary.
+    def to_ary
+      to_a
+    end
+
     def to_a
       i = 0
       wrapped = wrapped_buffer

data/lib/moxml/version.rb

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

data/lib/moxml/xpath/compiler.rb

@@ -892,9 +892,21 @@ module Moxml
         end
       end
 
-      # Union: | (pipe)
-      def on_pipe(ast, input)
-        left, right = ast.children
+      # Union: | (pipe). Unions are N-ARY — the parser flattens
+      # a|b|c into one union node — and may nest (parenthesized
+      # groups become union children). Every member's nodes flow
+      # through the block when one is given (nested unions), else
+      # into one result NodeSet (#315: the old two-children
+      # destructure silently dropped every branch after the second).
+      def on_pipe(ast, input, &block)
+        if block
+          code = nil
+          ast.children.each do |child|
+            fragment = process(child, input, &block)
+            code = code ? code.followed_by(fragment) : fragment
+          end
+          return code
+        end
 
         union = unique_literal(:union)
         context_var = context_literal
@@ -903,22 +915,13 @@ module Moxml
         nodeset_class = const_ref("Moxml", "NodeSet")
         empty_array = Ruby::Node.new(:array, [])
 
-        # Expressions such as "a | b | c"
-        if left.type == :pipe
-          union.assign(process(left, input))
-            .followed_by(process(right, input) { |node| union << node })
-            .followed_by(union)
-        # Expressions such as "a | b"
-        else
-          nodeset_new = Ruby::Node.new(:send,
-                                       [nodeset_class, "new", empty_array,
-                                        context_var])
-
-          union.assign(nodeset_new)
-            .followed_by(process(left, input) { |node| union << node })
-            .followed_by(process(right, input) { |node| union << node })
-            .followed_by(union)
+        code = union.assign(Ruby::Node.new(:send,
+                                           [nodeset_class, "new", empty_array,
+                                            context_var]))
+        ast.children.each do |child|
+          code = code.followed_by(process(child, input) { |node| union << node })
         end
+        code.followed_by(union)
       end
 
       # Variable: $variable

data/spec/moxml/at_search_spec.rb

@@ -82,4 +82,305 @@ RSpec.describe "Nokogiri-compatible node sugar" do
       expect(doc.root.children.map(&:name)).to eq(%w[a x text b])
     end
   end
+
+  describe "Node#<< append sugar" do
+    it "appends parsed fragments from strings" do
+      doc = Moxml.parse("<r/>")
+      doc.root << "<a/><b/>"
+      expect(doc.root.children.map(&:name)).to eq(%w[a b])
+    end
+
+    it "appends plain text as a text node" do
+      text_parent = Moxml.parse("<p/>").root
+      text_parent << "hello"
+      expect(text_parent.text).to eq("hello")
+    end
+
+    it "appends nodes" do
+      doc = Moxml.parse("<r/>")
+      doc.root << Moxml.parse("<b/>").root
+      expect(doc.root.children.map(&:name)).to eq(%w[b])
+    end
+
+    it "returns self for chaining" do
+      doc = Moxml.parse("<r/>")
+      expect(doc.root << "<a/>").to be(doc.root)
+    end
+  end
+
+  describe "Element#delete" do
+    it "removes an attribute by name" do
+      doc = Moxml.parse("<r annex='yes' id='x'/>")
+      doc.root.delete("annex")
+      expect(doc.root["annex"]).to be_nil
+      expect(doc.root["id"]).to eq("x")
+    end
+  end
+
+  describe "Element#children=" do
+    it "replaces all children with a string" do
+      doc = Moxml.parse("<r><old/>text</r>")
+      doc.root.children = "<a/><b/>"
+      expect(doc.root.children.map(&:name)).to eq(%w[a b])
+    end
+
+    it "replaces with a node" do
+      doc = Moxml.parse("<r><old/></r>")
+      node = Moxml.parse("<x/>").root
+      doc.root.children = node
+      expect(doc.root.children.map(&:name)).to eq(%w[x])
+    end
+
+    it "replaces with an array of nodes" do
+      doc = Moxml.parse("<r><old/></r>")
+      frag = Moxml.parse("<w><x/><y/></w>").root.children
+      doc.root.children = frag
+      expect(doc.root.children.map(&:name)).to eq(%w[x y])
+    end
+
+    it "invalidates memoized children holders" do
+      doc = Moxml.parse("<r><old/></r>")
+      root = doc.root
+      root.children
+      root.children = "<new/>"
+      expect(root.children.map(&:name)).to eq(%w[new])
+    end
+  end
+
+  describe "Element#elements" do
+    it "returns only element children" do
+      doc = Moxml.parse("<r>text<a/><!-- c --><b/></r>")
+      expect(doc.root.elements.map(&:name)).to eq(%w[a b])
+      expect(doc.root.element_children.map(&:name)).to eq(%w[a b])
+    end
+
+    it "stays fresh across mutations" do
+      doc = Moxml.parse("<r><a/></r>")
+      root = doc.root
+      expect(root.elements.map(&:name)).to eq(%w[a])
+      root.add_child(doc.create_element("b"))
+      expect(root.elements.map(&:name)).to eq(%w[a b])
+    end
+  end
+
+  describe "NodeSet#- difference" do
+    it "removes nodes present in the other set" do
+      doc = Moxml.parse("<r><a/><b/><c/></r>")
+      diff = doc.root.children - doc.search("//a")
+      expect(diff.map(&:name).sort).to eq(%w[b c])
+    end
+  end
+
+  describe "NodeSet#to_ary" do
+    it "flattens inside arrays" do
+      doc = Moxml.parse("<r><a/><b/></r>")
+      flat = [doc.root, doc.root.elements].flatten
+      expect(flat.map(&:name)).to include("r", "a", "b")
+    end
+  end
+
+  describe "Node#ancestors(selector)" do
+    it "filters ancestors by element name" do
+      doc = Moxml.parse("<r><table><tr><td><p/></td></tr></table></r>")
+      p_node = doc.at("//p")
+      expect(p_node.ancestors("table").map(&:name)).to eq(%w[table])
+      expect(p_node.ancestors.map(&:name)).to include("td", "tr", "table")
+    end
+  end
+
+  describe "Node#next_element/previous_element" do
+    it "skips interleaved text nodes" do
+      doc = Moxml.parse("<r><a/>text<b/></r>")
+      a = doc.at("//a")
+      expect(a.next_element.name).to eq("b")
+      expect(doc.at("//b").previous_element.name).to eq("a")
+    end
+  end
+
+  describe "Node#parent= reparenting" do
+    it "moves a node under a new parent" do
+      doc = Moxml.parse("<r><from><p/></from><to/></r>")
+      p_node = doc.at("//p")
+      p_node.parent = doc.at("//to")
+      expect(doc.at("//to/p")).not_to be_nil
+      expect(doc.at("//from/p")).to be_nil
+    end
+  end
+
+  describe "NodeSet#to_xml" do
+    it "serializes the set's members in order" do
+      doc = Moxml.parse("<r><a>x</a>tail</r>")
+      expect(doc.root.children.to_xml).to eq("<a>x</a>tail")
+    end
+  end
+
+  describe "Node#add_first_child" do
+    it "inserts before existing children and handles empty parents" do
+      doc = Moxml.parse("<r><b/></r>")
+      doc.root.add_first_child("<a/>")
+      expect(doc.root.children.map(&:name)).to eq(%w[a b])
+      Moxml.parse("<r/>").root.add_first_child("<x/>")
+    end
+  end
+
+  describe "Node#remove on a detached node" do
+    it "is a no-op returning self (Nokogiri parity)" do
+      doc = Moxml.parse("<r><p><c/></p><t/></r>")
+      p_node = doc.at("//p")
+      t = doc.create_element("d")
+      p_node.replace(t)
+      expect(p_node.parent).to be_nil
+      expect(p_node.remove).to equal(p_node)
+      t << p_node
+      expect(t.children.map(&:name)).to eq(%w[p])
+      expect(doc.at("//d/p/c")).not_to be_nil
+    end
+  end
+
+  describe "Element#replace + re-attach under the replacement" do
+    it "does not cycle the tree (leptris stale-run splice)" do
+      doc = Moxml.parse("<r><a>x</a><b/></r>")
+      a = doc.at("//a")
+      t = doc.create_element("t")
+      a.replace(t)
+      t << a
+      expect(doc.root.children.map(&:name)).to eq(%w[t b])
+      expect(t.children.map(&:name)).to eq(%w[a])
+      expect(doc.at("//t/a/text()").text).to eq("x")
+    end
+  end
+
+  describe "Node/NodeSet#to_s interpolation" do
+    it "serializes instead of Object#to_s" do
+      doc = Moxml.parse("<r><a>x</a><b/></r>")
+      # rubocop:disable Style/RedundantInterpolation -- the interpolation IS the contract under test
+      node = doc.at("//a")
+      expect("#{node}").to eq("<a>x</a>")
+      children = doc.root.children
+      expect("#{children}").to eq("<a>x</a><b></b>")
+      # rubocop:enable Style/RedundantInterpolation
+    end
+  end
+
+  describe "Element#default_namespace=" do
+    it "binds the element to the default namespace" do
+      doc = Moxml.parse("<r><math><mi>x</mi></math></r>")
+      math = doc.at("//math")
+      math.default_namespace = "http://www.w3.org/1998/Math/MathML"
+      expect(math.namespace_uri.to_s).to eq("http://www.w3.org/1998/Math/MathML")
+      expect(math.to_xml).to include('xmlns="http://www.w3.org/1998/Math/MathML"')
+    end
+  end
+
+  describe "Node#to_str" do
+    it "yields the text content" do
+      doc = Moxml.parse("<r><s>a<b>c</b>d</s></r>")
+      expect(doc.at("//s").to_str).to eq("acd")
+      expect(doc.at("//b").to_str).to eq("c")
+    end
+  end
+
+  describe "Element#content=" do
+    it "replaces children with the given text" do
+      doc = Moxml.parse("<r><s><b>x</b>y</s></r>")
+      s = doc.at("//s")
+      s.content = "1 < 2"
+      expect(s.children.size).to eq(1)
+      expect(s.content).to eq("1 < 2")
+      expect(s.to_xml).to eq("<s>1 &lt; 2</s>")
+    end
+  end
+
+  describe "Node#next/previous readers" do
+    it "return adjacent siblings" do
+      doc = Moxml.parse("<r><a/>mid<b/></r>")
+      a = doc.at("//a")
+      expect(a.next.name).to eq("text")
+      expect(a.next.next.name).to eq("b")
+      expect(doc.at("//b").previous.name).to eq("text")
+      expect(doc.at("//b").previous.previous.name).to eq("a")
+    end
+  end
+
+  describe "Node#path for non-element nodes" do
+    it "builds type-test segments" do
+      doc = Moxml.parse("<r><p>a<!--c--></p><p>b</p></r>")
+      expect(doc.at("//p").path).to eq("/r/p[1]")
+      texts = doc.xpath("//p/text()")
+      expect(texts[0].path).to eq("/r/p[1]/text()")
+      expect(doc.xpath("//p/comment()").first.path).to eq("/r/p[1]/comment()")
+    end
+  end
+
+  describe "Document#root= with a foreign root" do
+    it "adopts the subtree from another document" do
+      doc = Moxml.parse("<old><x/></old>")
+      other = Moxml.parse(%(<r xmlns="urn:x" a="1"><p>hi<b>t</b></p></r>))
+      doc.root = other.root
+      expect(doc.to_xml(indent: 0).strip)
+        .to eq(%(<r xmlns="urn:x" a="1"><p>hi<b>t</b></p></r>))
+      expect(doc.root.namespace_uri.to_s).to eq("urn:x")
+    end
+  end
+
+  describe "String operands are markup, not literal text" do
+    it "add_child / add_next_sibling / add_previous_sibling parse strings" do
+      doc = Moxml.parse("<r><a/></r>")
+      a = doc.at("//a")
+      a.add_child("<c/>")
+      a.add_next_sibling("<d/>")
+      a.add_previous_sibling("<b/>")
+      expect(a.children.map(&:name)).to eq(%w[c])
+      expect(doc.root.children.map(&:name)).to eq(%w[b a d])
+      expect(doc.at("//r/a/c")).not_to be_nil
+    end
+  end
+
+  describe "Markup-string insertion returns a NodeSet of new nodes" do
+    it "add_child / add_next_sibling return the new nodes; nodes return self" do
+      doc = Moxml.parse("<r><a/></r>")
+      a = doc.at("//a")
+      kids = a.add_child("<c1/><c2/>")
+      expect(kids).to be_a(Moxml::NodeSet)
+      expect(kids.map(&:name)).to eq(%w[c1 c2])
+      sibs = a.add_next_sibling("<n1/><n2/>")
+      expect(sibs.map(&:name)).to eq(%w[n1 n2])
+      expect(doc.root.children.map(&:name)).to eq(%w[a n1 n2])
+      prev = a.add_previous_sibling("<p1/><p2/>")
+      expect(prev.map(&:name)).to eq(%w[p1 p2])
+      expect(doc.root.children.map(&:name)).to eq(%w[p1 p2 a n1 n2])
+      expect(a.add_child(doc.at("//p1"))).to equal(a)
+    end
+  end
+
+  describe "default_namespace= idempotence" do
+    it "does not duplicate an identical in-scope default namespace" do
+      doc = Moxml.parse(%(<r xmlns="urn:x"><math xmlns="urn:m"/></r>))
+      math = doc.at("//m:math", "m" => "urn:m")
+      math.default_namespace = "urn:m"
+      expect(math.to_xml).to eq(%(<math xmlns="urn:m"></math>))
+    end
+  end
+
+  describe "xpath with namespace bindings" do
+    it "prefixed star and name tests honor the namespace URI" do
+      # m must be DECLARED on the element — a bare m:title with only
+      # a default xmlns is a no-namespace element whose literal name
+      # carries the colon, and no prefix binding can select it.
+      doc = Moxml.parse(%(<r><bibdata/><m:title xmlns:m="urn:x"/></r>))
+      hits = doc.root.xpath(".//m:*", "m" => "urn:unitsml")
+      expect(hits.map(&:name)).to eq([])
+      named = doc.root.at_xpath(".//m:title", "m" => "urn:x")
+      expect(named&.name).to eq("title")
+      none = doc.root.at_xpath(".//m:title", "m" => "urn:unitsml")
+      expect(none).to be_nil
+    end
+  end
+
+  describe "Element#inner_xml" do
+    it "serializes the children" do
+      doc = Moxml.parse("<r><a>x</a><b/></r>")
+      expect(doc.root.inner_xml).to eq("<a>x</a><b/>")
+    end
+  end
 end

data/spec/moxml/xpath/union_spec.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# moxml#315: unions are N-ARY in the parser (a|b|c parses to one
+# union node); the compiler's two-children destructure silently
+# dropped every branch after the second. The reserved xmlns prefix
+# hid the drop for namespaced consumers because those queries rode
+# the native seam; when they fell back to the Ruby engine (or on
+# adapters whose engine IS this one, e.g. ox), branches vanished.
+RSpec.describe "XPath union compilation" do
+  let(:ctx) { Moxml.new(:leptris) }
+  let(:doc) { ctx.parse('<r xmlns="urn:x"><a>1</a><b>2</b><c>3</c></r>') }
+
+  it "keeps every branch of a flat n-ary union (moxml#315)" do
+    r = doc.at_xpath("/xmlns:r", { "xmlns" => "urn:x" })
+    names = r.xpath("./xmlns:a|./xmlns:b|./xmlns:c", { "xmlns" => "urn:x" })
+      .map(&:text)
+    expect(names).to eq(%w[1 2 3])
+  end
+
+  it "keeps branches under the reserved xmlns prefix through the engine" do
+    r = doc.at_xpath("/xmlns:r", { "xmlns" => "urn:x" })
+    ast = Moxml::XPath::Parser.parse("./xmlns:a|./xmlns:b|./xmlns:c")
+    proc_c = Moxml::XPath::Compiler.compile_with_cache(ast, namespaces: { "xmlns" => "urn:x" })
+    expect(proc_c.call(r).to_a.map(&:text)).to eq(%w[1 2 3])
+  end
+
+  it "keeps parenthesized nested unions" do
+    r = doc.at_xpath("/xmlns:r", { "xmlns" => "urn:x" })
+    ast = Moxml::XPath::Parser.parse("(./xmlns:a|./xmlns:b)|./xmlns:c")
+    proc_c = Moxml::XPath::Compiler.compile_with_cache(ast, namespaces: { "xmlns" => "urn:x" })
+    expect(proc_c.call(r).to_a.map(&:text)).to eq(%w[1 2 3])
+  end
+
+  it "unions still work on adapters whose engine is the Ruby engine" do
+    ctx_ox = Moxml.new(:ox)
+    doc_ox = ctx_ox.parse("<r><a>1</a><b>2</b><c>3</c></r>")
+    r = doc_ox.root
+    expect(r.xpath("./a|./b|./c").map(&:text)).to eq(%w[1 2 3])
+  end
+end

data/spec/moxml/xslt/stylesheet_spec.rb

@@ -4,8 +4,9 @@ require "spec_helper"
 
 # The Moxml::XSLT contract: compile once, apply many. Only engines
 # with an XSLT processor implement it (nokogiri/libxslt; leptris
-# covering XSLT 1.0-3.0). leptris does not thread top-level params
-# yet (leptris-ruby#360) — non-empty params raise Moxml::XsltError.
+# covering XSLT 1.0-3.0). Bindings >= 1.9.290.0 thread top-level
+# params (leptris#1478); older bindings raise Moxml::XsltError
+# citing leptris-ruby#360.
 SHEET_COUNT = <<~XSL
   <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
     <xsl:template match="/"><out><xsl:value-of select="count(//i)"/></out></xsl:template>
@@ -77,10 +78,22 @@ RSpec.describe "Moxml::XSLT" do
       expect(sheet.apply_to_string(doc)).to include("plain text result")
     end
 
-    it "raises XsltError on non-empty params (leptris-ruby#360)" do
-      sheet = ctx.xslt(SHEET_COUNT)
-      expect { sheet.apply_to(doc, params: { "n" => "7" }) }
-        .to raise_error(Moxml::XsltError, /params.*#360/)
+    if Gem::Version.new(Leptris::VERSION) >= Gem::Version.new("1.9.290.0")
+      it "threads top-level params (leptris#1478)" do
+        sheet = ctx.xslt(<<~XSL)
+          <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
+            <xsl:param name="n" select="'0'"/>
+            <xsl:template match="/"><out><xsl:value-of select="$n"/></out></xsl:template>
+          </xsl:stylesheet>
+        XSL
+        expect(sheet.apply_to_string(doc, params: { "n" => "7" })).to include("7")
+      end
+    else
+      it "raises XsltError on non-empty params (leptris-ruby#360)" do
+        sheet = ctx.xslt(SHEET_COUNT)
+        expect { sheet.apply_to(doc, params: { "n" => "7" }) }
+          .to raise_error(Moxml::XsltError, /params.*#360/)
+      end
     end
 
     it "reports support" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.101
+  version: 0.5.103
 platform: ruby
 authors:
 - Ribose Inc.
@@ -560,6 +560,7 @@ files:
 - spec/moxml/xpath/parser_spec.rb
 - spec/moxml/xpath/ruby/generator_spec.rb
 - spec/moxml/xpath/ruby/node_spec.rb
+- spec/moxml/xpath/union_spec.rb
 - spec/moxml/xpath_capabilities_spec.rb
 - spec/moxml/xpath_spec.rb
 - spec/moxml/xslt/stylesheet_spec.rb