moxml 0.5.100 → 0.5.102

data/lib/moxml/node.rb

@@ -74,6 +74,11 @@ module Moxml
     end
 
     def children
+      # Generation-checked memo: mutations bump the context counter, so
+      # this self-invalidates even when the same logical node is served
+      # by multiple wrapper representations (native vs binding duality).
+      @children = nil if @children_gen != context.children_generation
+      @children_gen = context.children_generation
       @children ||= begin
         # The wrapper's entity memo decides the marker split; the
         # adapter would otherwise re-derive it per call (a C parent
@@ -99,7 +104,105 @@ 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)
       # Refresh native in case adapter changed identity (e.g., LibXML
@@ -115,21 +218,40 @@ 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)
+      # Invalidate the parent's memoized children list. The wrapper-side
+      # @parent_node link is only set when this node was yielded through a
+      # parent-aware NodeSet; nodes obtained via at()/xpath() carry no such
+      # link, so resolve the parent wrapper from the adapter instead.
+      parent&.invalidate_children_cache!
       invalidate_parent_children_cache!
       self
     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)
-      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)
       invalidate_children_cache!
@@ -143,6 +265,7 @@ module Moxml
     def invalidate_namespace_cache!; end
 
     def replace(node)
+      context.bump_children_generation
       node = prepare_node(node)
       invalidate_parent_children_cache!
       adapter.replace(@native, node.native)
@@ -171,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
@@ -215,6 +350,42 @@ module Moxml
                        context)
     end
 
+    # Nokogiri-compatible sugar: at/search/at_css/css. Nokogiri's
+    # at/search auto-detect XPath vs CSS; the XPath-first fallback
+    # covers the dominant caller shape (XPath expression strings)
+    # while css/at_css serve stylesheet-style selectors.
+    def at(expression, namespaces = {})
+      at_css_or_xpath(expression, namespaces)
+    end
+
+    def search(expression, namespaces = {})
+      xpath(expression, namespaces)
+    end
+
+    def css(_expression)
+      raise Moxml::NotImplementedError,
+            "CSS selectors are not supported; use search with XPath"
+    end
+
+    def at_css(_expression)
+      raise Moxml::NotImplementedError,
+            "CSS selectors are not supported; use at with XPath"
+    end
+
+    def at_css_or_xpath(expression, namespaces = {})
+      at_xpath(expression, namespaces)
+    end
+
+    # Nokogiri-compatible depth-first traversal: yields self, then
+    # children recursively (document-order visitor).
+    def traverse(&block)
+      return to_enum(:traverse) unless block
+
+      yield self
+      children.each { |child| child.traverse(&block) }
+      self
+    end
+
     # Convenience find methods (aliases for xpath methods)
     def find(xpath_expression, namespaces = {})
       at_xpath(xpath_expression, namespaces)
@@ -307,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 = []
@@ -371,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?
@@ -392,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.
@@ -496,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)
@@ -591,6 +780,13 @@ module Moxml
     def self.wrap_with(node, context, adapter)
       return nil if node.nil?
 
+      # One C node may have several Ruby representations (leptris
+      # native/binding duality, moxml#311); every wrap resolves to
+      # the canonical one so memo holders share one invalidation
+      # chain. A hit-only lookup: a memoized holder implies a prior
+      # walk, which is what populates the canonical map.
+      node = adapter.canonical_native(node)
+
       # Cache-stable binding nodes carry their wrapper directly
       # (#312): the binding's document-owned cache hands the SAME
       # node object for the engine node's whole lifetime, so an

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/text.rb

@@ -33,5 +33,8 @@ module Moxml
     def name
       "text"
     end
+
+    # Nokogiri-compatible: renaming non-element nodes is a no-op
+    def name=(_value); end
   end
 end

data/lib/moxml/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Moxml
-  VERSION = "0.5.100"
+  VERSION = "0.5.102"
 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/adapter/leptris_binding_cap_spec.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# 0.5.100's cap valves called .clear on the registry — an
+# ObjectSpace::WeakMap in weak-wrapper mode (Ruby 3.4+) has no
+# #clear, so the first parse crossing 8,192 bridges crashed with
+# NoMethodError. The valve replaces the registry wholesale now.
+RSpec.describe "leptris binding registry cap valve" do
+  let(:ctx) { Moxml.new(:leptris) }
+  let(:doc) do
+    ctx.parse("<r>#{Array.new(8_300) { |i| "<e#{i}/>" }.join}</r>")
+  end
+
+  it "bridges past the cap" do
+    children = doc.root.children.to_a
+    expect(children.size).to be > 8_192
+
+    bridged = children.map { |child| Moxml::Adapter::Leptris.to_binding(child.native) }
+    expect(bridged.compact.size).to eq(children.size)
+  end
+
+  it "bridges stay identity-stable across the valve" do
+    children = doc.root.children.to_a
+    first_pass = children.map { |child| Moxml::Adapter::Leptris.to_binding(child.native) }
+    second_pass = children.map { |child| Moxml::Adapter::Leptris.to_binding(child.native) }
+    expect(first_pass.zip(second_pass).all? { |one, other| one.equal?(other) }).to be(true)
+  end
+end

data/spec/moxml/adapter/leptris_xpath_identity_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# moxml#311: the native and binding layers hold separate Ruby objects
+# over one C node. An xpath-resolved node that failed to resolve to
+# the tree-walk identity carried no parent link, so sibling inserts
+# through it never invalidated the memoized children of wrappers
+# handed out before the query — the insert serialized but stayed
+# invisible through parent.children.
+RSpec.describe "leptris xpath nodes resolve canonical identity" do
+  let(:ctx) { Moxml.new(:leptris) }
+  let(:doc) { ctx.parse("<r><a>t</a>\n<b/></r>") }
+
+  it "at_xpath returns the walked wrapper" do
+    root = doc.root
+    walked = root.children.first
+    expect(root.at_xpath("a")).to be(walked)
+  end
+
+  it "xpath list results resolve canonical identity" do
+    root = doc.root
+    walked = root.children.first
+    expect(root.xpath("a").first).to be(walked)
+  end
+
+  it "namespace-bound at_xpath resolves canonical identity" do
+    root = doc.root
+    walked = root.children.first
+    expect(root.at_xpath("a", "xmlns" => "http://x")).to be(walked)
+  end
+
+  it "sibling insert through at_xpath resolves in parent.children" do
+    root = doc.root
+    root.children
+    a = root.at_xpath("a")
+    a.add_next_sibling(ctx.parse_fragment("<x/>").first)
+    expect(root.children.map(&:name)).to eq(%w[a x text b])
+  end
+
+  it "sibling insert through the engine path resolves in parent.children" do
+    root = doc.root
+    root.children
+    walked = root.children.first
+    a = walked.at_xpath("self::a[parent::r]")
+    a.add_next_sibling(ctx.parse_fragment("<x/>").first)
+    expect(root.children.map(&:name)).to eq(%w[a x text b])
+  end
+end