moxml 0.5.100 → 0.5.102

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a421da0e82158a69de2d25328346153be526d74c6d2bc2bad732427763b175c1
-  data.tar.gz: c9d982a98b2ce4984b3ee8659e89f2a4d86484d7e39fec4c04221bd2767473eb
+  metadata.gz: d182614a13bd3934c6d6dc1bb9b137015dc1daa124aeac24df40246ea3109103
+  data.tar.gz: 51d96b5f964b185772d4378913c5e48e4775c41cf5fd1a3e5cf942576fa33183
 SHA512:
-  metadata.gz: 2a3c9a536530f058a8c0a7721a3f192d89be195df277e959d746f2b6360db2da3587c2467fc21222aff85b96c8c3483a6a59406554804e073b25336c6d5dfe17
-  data.tar.gz: 750f9751134a3c077bd103edb9b18b0de7ea179d0c27839f1dff22654d372d7eb989a55c154c09ee155ec64d386547885013320eefa4044cb7dccc994d309806
+  metadata.gz: f4e9ae7331917e4fb295aa541028cb233d889127e4e32982d24ad1d696df668f52d223b70a1c6f2e96360f72138abf36a2eb055f15b9f48c069cb7b421191cfe
+  data.tar.gz: '0362854ca321c56e434a0f030232088d200d948dfe231c2d2cf4d2017c3af7316610e3f18ece3ca85a9a9a2c0d98f431c9f3bb465f186fe39ae23b63ea2e9a7b'

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
@@ -146,6 +149,22 @@ module Moxml
           nil
         end
 
+        # Canonical node identity: adapters carrying more than one
+        # Ruby representation over one C node answer the representation
+        # the tree walk mints, so every wrap path resolves one wrapper
+        # per logical node (moxml#311). Default: the node is canonical.
+        def canonical_native(node)
+          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
@@ -386,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/document_parts.rb

@@ -48,7 +48,7 @@ module Moxml
           # equal?-based exclusion (canon's document-element skip)
           # silently breaks (issue #219). Mint-on-miss converges
           # both accessors on the same native object.
-          children.map! { |child| canonical_native(doc, child) } if NATIVE_READ_LAYER
+          children.map! { |child| native_twin(doc, child) } if NATIVE_READ_LAYER
           children
         end
 

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)
@@ -168,6 +172,18 @@ module Moxml
       BINDING_OF_CAP = 8_192
 
       class << self
+        # WeakMap has no #clear — 0.5.100's valve crashed every parse
+        # crossing the cap on 3.4+ (NoMethodError). Replace the
+        # registry wholesale, type-preserving: the WeakMap flavor
+        # stays weak, the strong Hash keeps compare_by_identity.
+        def fresh_node_registry
+          if Context::WEAK_WRAPPERS
+            ObjectSpace::WeakMap.new
+          else
+            {}.compare_by_identity
+          end
+        end
+
         # native -> bridged binding node. The bridge object is
         # identity-stable for the native's lifetime (the binding's
         # per-document wrap cache), so repeat bridges — the write
@@ -187,7 +203,7 @@ module Moxml
           doc = doc_for(node)
           ptr = ::FFI::Pointer.new(node.address)
           bridged = ::Leptris::XML::Node.wrap(ptr, doc)
-          @binding_of.clear if @binding_of.size >= BINDING_OF_CAP
+          @binding_of = fresh_node_registry if @binding_of.size >= BINDING_OF_CAP
           @binding_of[node] = bridged unless bridged.nil?
           bridged
         end
@@ -428,7 +444,7 @@ module Moxml
           end
 
           def record_native_doc(root_native, doc)
-            @native_doc_roots.clear if @native_doc_roots.size >= NATIVE_DOC_ROOTS_CAP
+            @native_doc_roots = fresh_node_registry if @native_doc_roots.size >= NATIVE_DOC_ROOTS_CAP
             @native_doc_roots[root_native] = doc
           end
 
@@ -1385,6 +1401,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
@@ -1511,7 +1540,7 @@ module Moxml
         # accessor converges on one native per node (issue #219).
         # Binding natives (Attribute/Attr, synthetic wrappers) and
         # docless nodes pass through unchanged.
-        def canonical_native(doc, node)
+        def native_twin(doc, node)
           return node unless node.is_a?(::Leptris::XML::Element)
 
           cache = doc.native_cache
@@ -1584,10 +1613,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)
@@ -1625,7 +1669,7 @@ module Moxml
             # Through the same address-keyed cache as the children
             # path: NativeNode.from alone mints a fresh object per
             # call on 1.9.163.x, splitting the wrappers (issue #219).
-            native = canonical_native(document, r)
+            native = native_twin(document, r)
             record_native_doc(native, document)
             return native
           end
@@ -1686,8 +1730,8 @@ module Moxml
           # convergence (#219) hands every accessor — children
           # included — the SAME native, so the wrapper identity
           # holds across later traversals.
-          canonical_native(doc,
-                           ::Leptris::XML::Node.wrap(::FFI::Pointer.new(addr), doc))
+          native_twin(doc,
+                      ::Leptris::XML::Node.wrap(::FFI::Pointer.new(addr), doc))
         end
 
         def attributes(element)
@@ -1839,6 +1883,7 @@ module Moxml
             node = to_binding(node)
             new_node = to_binding(new_node)
           end
+          pin_foreign_owner_document(node, new_node)
           # A PI inserted before the root lives at document level in
           # libleptris's model, not in the element tree.
           if new_node.is_a?(::Leptris::XML::ProcessingInstruction) &&
@@ -1864,6 +1909,7 @@ module Moxml
             node = to_binding(node)
             new_node = to_binding(new_node)
           end
+          pin_foreign_owner_document(node, new_node)
           return node.add_next_sibling(new_node) if node.is_a?(::Leptris::XML::Element)
 
           # Non-element receivers (Text/Comment/CDATA): the binding's
@@ -1935,7 +1981,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
@@ -2118,6 +2176,29 @@ module Moxml
           engine_xpath(node, expression, namespaces)
         end
 
+        # Canonical node identity (moxml#311): the native layer and
+        # the binding layer hold separate Ruby objects over one C
+        # node, and only the native cache carries the tree-walk
+        # identity the @parent_node invalidation chain rides on.
+        # Resolve binding-layer nodes (xpath results, engine results)
+        # to the walked instance when one exists — a memoized
+        # children holder implies a prior walk, so a cache miss means
+        # no holder exists and the binding node is safe as-is.
+        def canonical_native(node)
+          return node unless NATIVE_READ_LAYER
+          return node if node.is_a?(::Leptris::XML::NativeNode)
+          return node unless node.is_a?(::Leptris::XML::Node)
+
+          doc = node.document
+          return node if doc.nil?
+
+          # Only a contract-carrying hit is the walked canonical —
+          # plain NN twins (entity references, #219 miss-mints) have
+          # no Identity class and keep the binding representation.
+          hit = doc.native_cache[node.c_ptr.address]
+          hit.is_a?(::Moxml::Node) ? hit : node
+        end
+
         def at_xpath(node, expression, namespaces = {})
           native = native_xpath(node, expression, namespaces, first_only: true)
           return native unless native.nil?
@@ -2138,7 +2219,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.
@@ -2194,7 +2290,8 @@ module Moxml
             # and frees in one C dispatch — no NodeSet container, no
             # AutoPointer (leptris-ruby TODO.perf/16). The module
             # object back means a scalar, whose wrap (and free)
-            # stays with wrap_xpath_first_result.
+            # stays with wrap_xpath_first_result. Identity resolution
+            # happens at the at_xpath boundary (bridge_xpath_node).
             return ::Leptris::XML::Searchable.wrap_xpath_first_result(
               document, result_ptr
             )
@@ -2273,6 +2370,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/cdata.rb

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

data/lib/moxml/comment.rb

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

data/lib/moxml/context.rb

@@ -74,6 +74,18 @@ module Moxml
       end
     end
 
+    # Children-memo generation: bumped by every tree mutation so
+    # per-wrapper children memos can self-invalidate even when the
+    # same logical node is reachable through multiple wrapper
+    # representations (native vs binding duality).
+    def children_generation
+      @children_generation ||= 0
+    end
+
+    def bump_children_generation
+      @children_generation = children_generation + 1
+    end
+
     def namespace_scope_generation
       @namespace_scope_generation
     end

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!
@@ -113,6 +145,14 @@ module Moxml
       Wrappers::EntityReference.new(native, context)
     end
 
+    # Nokogiri-compatible: Document#name returns "document"
+    def name
+      "document"
+    end
+
+    # Nokogiri-compatible: renaming a document node is a no-op
+    def name=(_value); end
+
     def add_child(node)
       node = prepare_node(node)
 

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