moxml 0.6.3 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 769900ed7676cee2de32bcb98a390616a5284bec301789ab95af7bc3d7384971
-  data.tar.gz: 9bd2bcb7eda50b2d4246ec8caea424971e291c00cbc6789e14c18c9f1ed61b7f
+  metadata.gz: ded5a4e91431d2dc0aa52f5ed3a013dafe8ff9dc5dbcb3490a4793c2e50882bc
+  data.tar.gz: 132da396e0ecb742951521cfcc12f04e1a250bd81607d8f0b9a00db1c926712f
 SHA512:
-  metadata.gz: bc5ad58955107e459f8432084c9a049d4217ac9b56a9a378969d14b88bcf8ac7cf582cfa9db899adb116ff5a1e4c88e93153eb9ef5d61066f3d6144045ccd359
-  data.tar.gz: 1f8b0344a42afbf5c3c8b59e43fa72e322a8700ecc2d39c1450c14f1cbed31c2b81b910ce34f8b20f422792b8e92ddfff0ad967d3fc61f6301722b836dd6f242
+  metadata.gz: df4fc2b129067c6ae6a7571abd150dcc53851e71a234cc11513842bddc45e4534502a983bd61c952ba8db8b54f85beefb9dc01dc4893e5df9155482ea2119758
+  data.tar.gz: 5703c216bd7bfd25da921e8c3b9f0dc9e87df3112cd644809a4564c1903007687611f1d734a8515b3477b8f75b6133eeb62ce0196a3d7ba6a4f3c1522448fb02

data/docs/_pages/divergences.adoc

@@ -156,3 +156,34 @@ before leptris#1866's fix (the fix itself is not the cause); not a
 regression of the fix. Noted in
 `spec/moxml/adapter/leptris_crossdoc_replace_spec.rb`.
 |===
+
+| D-23
+| leptris (XSD engine lane, before 1.9.409)
+| Strict wildcard/anyAttribute admission consulted only the head
+unit's declaration table, so items declared in a NON-head unit of a
+composition (xsi:schemaLocation hint documents) got "not declared
+(strict)" rows. The facade owns the composition: Schema#validate
+resolves the instance's hints against the schema path, walks the
+schema graph (include/import/redefine) for the unit closure, and
+dismisses refutable rows — global declarations AND group members
+(moxml#528; group admission this entry's companion). RESOLVED
+engine-side by leptris/leptris#1964 (v1.9.409, namespace-aware
+particle typing): the 16-case W3C set (attgD019-034, attgC035-038,
+addB114) answers VALID through the facade. Verified through the
+lutaml-xsd conformance runner (locations registration
+lutaml/lutaml-xsd#234); pinned in `spec/moxml/xsd_composed_spec.rb`.
+
+| D-24
+| leptris (XSD engine lane, 1.9.409+)
+| The 1.9.409 namespace-aware particle typing regresses the W3C
+schG2 composition (A imports no-ns B; expected valid): the engine
+types the no-namespace `<e1>` variant's children against ns-a's
+same-name declarations, so the lane answers INVALID where the model
+says VALID. v1.9.410 (leptris/leptris#1976) fixed the element
+resolution — the false lexical rows for the import-RESOLVED compile
+remain: the child-typing branch still resolves the no-ns `e1`'s
+`<a1>` against ns-a's `ct-A`, tracked upstream as
+leptris/leptris#1979. Until it lands the lexical rows pass through
+the facade untouched (they are not admission rows and are never
+dismissable).
+|===

data/lib/moxml/adapter/leptris.rb

@@ -80,6 +80,28 @@ module Moxml
         end
       end
 
+      # The address-native lane's native (leptris-ruby#587/#589/#591):
+      # a node as (binding document, raw C address, parent-reported
+      # kind). Plain Ruby — one allocation per node, no TypedData
+      # wrap, no binding identity-cache crossing. Reads resolve
+      # through the address-keyed C faces; writes bridge through
+      # #to_binding (address + document answer the bridge's
+      # questions). The per-document token cache (#address_native)
+      # hands the SAME token back per address while the document is
+      # unmutated, so wrapper identity rides the context registry
+      # unchanged. +kind+ is the children_addrs integer (0 element,
+      # 1 text, 2 comment, 3 cdata, 4 pi) — VISIT_NODE_TYPES'
+      # order.
+      class AddressNode
+        attr_reader :document, :address, :kind
+
+        def initialize(document, address, kind)
+          @document = document
+          @address = address
+          @kind = kind
+        end
+      end
+
       if Gem::Version.new(::Leptris::VERSION.to_s) <
           Gem::Version.new(MINIMUM_BINDING_VERSION)
         raise Moxml::AdapterError.new(
@@ -96,12 +118,10 @@ module Moxml
       # Attribute-node xpath results carry proper wrappers since
       # 1.9.105 (leptris-ruby#153: ResultAttr with name/value);
       # before that the native gate routed them to the Ruby engine.
-      ATTR_RESULT_NATIVE = true
 
       # leptris_node_digest shipped in bindings 1.9.99 (libleptris
       # 1.9.99, engine #869): on-demand Merkle subtree hash, zero
       # cost when unused. Below it, Node#digest answers nil.
-      DIGEST_SUPPORTED = true
 
       # 1.9.163.7 added the XPath seams (TODO.perf/15+16):
       # Searchable#at_xpath materializes nodeset entry 0 and frees
@@ -186,6 +206,20 @@ module Moxml
         defined?(::Leptris::XML::Native) &&
         ::Leptris::XML::Native.respond_to?(:walk_columnar)
 
+      # The address-keyed shadow faces (leptris-ruby#587/#589/#591):
+      # children_addrs(parent) => [addrs, kinds] accepts a raw
+      # address Integer, and the fast_* read faces (name, element
+      # text, comment/cdata/pi payloads) read by address. The
+      # address-native lane mints a plain AddressNode per node
+      # instead of the TypedData wrap + identity-cache crossing the
+      # columnar lane pays in C. Face-probed, not version-gated.
+      ADDRESS_NATIVE =
+        defined?(::Leptris::XML::Native) &&
+        ::Leptris::XML::Native.respond_to?(:children_addrs) &&
+        ::Leptris::XML::Native.respond_to?(:walk_addresses) &&
+        ::Leptris::XML::Native.respond_to?(:fast_name) &&
+        ::Leptris::XML::Native.respond_to?(:fast_text_content)
+
       # 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).
@@ -240,7 +274,6 @@ module Moxml
       # 1.9.181 (lockstep): Node#source_position — {line, col_start,
       # col_end} from the engine's source-position API (upstream
       # #1124); created nodes report zeros.
-      NATIVE_SOURCE_POSITION = true
 
       # Entity-reference preservation (leptris-ruby#212 / upstream
       # #1094): 1.9.177 ships ParseOptions.keep_entity_refs plus
@@ -268,7 +301,6 @@ module Moxml
       # so the gate names the first release where the drain is
       # CORRECT, not merely present. Dev floor pins ~> 1.9.238;
       # older bindings take the callback Parser below.
-      NATIVE_SAX_RECORDS = true
 
       # Document#absorb (engine #1548): one call transfers a source
       # document's pool ownership into the destination, so
@@ -429,7 +461,7 @@ module Moxml
             native_bulk_fixed: !NATIVE_BULK_FIXED.nil?,
             native_plan_structs: NATIVE_PLAN_STRUCTS,
             native_plan_typed: NATIVE_PLAN_TYPED,
-            digest: DIGEST_SUPPORTED && engine_serves?(:digest),
+            digest: engine_serves?(:digest),
             xsd: XSD_SUPPORTED && engine_serves?(:xsd),
             relaxng: RELAXNG_SUPPORTED && engine_serves?(:relaxng),
             xslt: XSLT_SUPPORTED && engine_serves?(:xslt),
@@ -664,12 +696,13 @@ module Moxml
 
         def to_binding(node)
           return node unless NATIVE_READ_LAYER &&
-            node.is_a?(::Leptris::XML::NativeNode)
+            (node.is_a?(::Leptris::XML::NativeNode) ||
+             node.is_a?(AddressNode))
 
           bridged = @binding_of[node]
           return bridged if bridged
 
-          doc = doc_for(node)
+          doc = node.is_a?(AddressNode) ? node.document : doc_for(node)
           ptr = ::FFI::Pointer.new(node.address)
           bridged = ::Leptris::XML::Node.wrap(ptr, doc)
           @binding_of = fresh_node_registry if @binding_of.size >= BINDING_OF_CAP
@@ -918,6 +951,15 @@ module Moxml
             # already-minted wrappers, so the adapter crossing
             # (bind_call + to_a + keep-refs probe) drops out, and
             # entity-marker documents take super for the split.
+            # NOTE (address-lane verdict, #531): the token arm was
+            # tried HERE and measured — tokens cannot serve the
+            # wrapper walk without breaking the klass-propagating
+            # identity contract (children vs element_children mint
+            # different wrapper classes for the same C node) and the
+            # wrapper lifecycle (tokens pin the binding document, so
+            # dropped documents stop releasing wrappers). The C-side
+            # klass-injected native cache is the walk lane; the
+            # address faces serve direct adapter consumers.
             if NN.method_defined?(:children_read)
               module ChildReads
                 def children
@@ -1093,8 +1135,10 @@ module Moxml
             end
 
             if NATIVE_READ_LAYER
-              native_one = one.is_a?(::Leptris::XML::NativeNode)
-              native_other = other.is_a?(::Leptris::XML::NativeNode)
+              native_one = one.is_a?(::Leptris::XML::NativeNode) ||
+                one.is_a?(AddressNode)
+              native_other = other.is_a?(::Leptris::XML::NativeNode) ||
+                other.is_a?(AddressNode)
               if native_one || native_other
                 address_one = native_one ? one.address : one.c_ptr.address
                 address_other = native_other ? other.address : other.c_ptr.address
@@ -1109,6 +1153,9 @@ module Moxml
           # to the root (C-bound reads) and look the doc up in the
           # root registry. Detached subtrees answer nil.
           def doc_for(node)
+            # Address tokens carry their document (set at mint).
+            return node.document if node.is_a?(AddressNode)
+
             # The 1.9.163.5 native layer exposes the owning document
             # directly; the root climb serves older bindings.
             return NN_DOCUMENT.bind_call(node) if NATIVE_MUTATIONS_COHERENT
@@ -1572,8 +1619,13 @@ module Moxml
         def bare_attr_value(element, name)
           # Exact-name C read: bare names target no-namespace
           # attributes (the documented contract — a bare "y" never
-          # resolves a "p:y" sibling).
-          value = if NATIVE_READ_LAYER && element.is_a?(NN)
+          # resolves a "p:y" sibling). Address tokens take the
+          # address-keyed attribute face.
+          value = if element.is_a?(AddressNode)
+                    ::Leptris::XML::Native.fast_attribute(
+                      element.address, name.to_s
+                    )
+                  elsif NATIVE_READ_LAYER && element.is_a?(NN)
                     NN_ATTRIBUTE.bind_call(element, name.to_s)
                   else
                     element[name.to_s]
@@ -2326,7 +2378,10 @@ module Moxml
         end
 
         def processing_instruction_target(node)
-          return to_binding(node).target if NATIVE_READ_LAYER && node.is_a?(NN)
+          if NATIVE_READ_LAYER &&
+              (node.is_a?(NN) || node.is_a?(AddressNode))
+            return to_binding(node).target
+          end
 
           node.target
         end
@@ -2344,6 +2399,12 @@ module Moxml
           # complete on the snapshot itself.
           return :attribute if node.is_a?(SnapshotAttribute)
 
+          # Address tokens carry the parent-reported WS kind.
+          if node.is_a?(AddressNode)
+            mapped = VISIT_NODE_TYPES[node.kind]
+            return mapped if mapped
+          end
+
           if node.is_a?(::Leptris::XML::Node) &&
               node.instance_variable_defined?(:@node_type)
             kind = node.instance_variable_get(:@node_type)
@@ -2388,8 +2449,9 @@ module Moxml
         # wrappers (declarations, doctypes, entity markers) and the
         # lightweight Attr triples answer nil.
         def digest(node, drop_ws_text: false)
-          return nil unless DIGEST_SUPPORTED
-          if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
+          if NATIVE_READ_LAYER &&
+              (node.is_a?(::Leptris::XML::NativeNode) ||
+               node.is_a?(AddressNode))
             return to_binding(node).digest(drop_ws: drop_ws_text)
           end
           return nil unless node.is_a?(::Leptris::XML::Node) &&
@@ -2401,6 +2463,18 @@ module Moxml
         def node_name(node)
           return node.root_name if node.is_a?(::Leptris::XML::DocType)
 
+          # Address tokens: the fast_name face is element-only (nil
+          # otherwise); PIs answer their target.
+          if node.is_a?(AddressNode)
+            if node.kind == 4
+              return ::Leptris::XML::Native.fast_pi_target(
+                node.address,
+              ).to_s
+            end
+
+            return ::Leptris::XML::Native.fast_name(node.address).to_s
+          end
+
           if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
             # PIs expose no name through the native layer.
             return to_binding(node).target.to_s if NN_NODE_TYPE.bind_call(node) == :pi
@@ -2475,7 +2549,30 @@ module Moxml
             return to_binding(node).children.to_a
           end
 
+          # Address tokens: element receivers take the token arm;
+          # terminal kinds answer [] through the case chain below.
+          if NATIVE_READ_LAYER && node.is_a?(AddressNode)
+            doc = node.document
+            return address_children(doc, node) if doc && node.kind.zero?
+
+            return []
+          end
+
           if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
+            # The address-native arm outranks the columnar lane: the
+            # same child lists, but the tokens are plain
+            # (document, address, kind) AddressNodes — the columnar
+            # crossing mints a TypedData wrap + identity-cache write
+            # per node in C, this arm allocates one plain token per
+            # node in Ruby (ADDRESS_NATIVE above). Element receivers
+            # only: their children's kinds are the WS enum the token
+            # carries; document receivers keep the assembly path
+            # (declaration/doctype kinds are outside the enum).
+            if ADDRESS_NATIVE && !entity_bearing && element_native?(node)
+              doc = doc_for(node)
+              return address_children(doc, node) if doc
+            end
+
             # Bulk C children through moxml's own scratch (see
             # NATIVE_READ_LAYER note above). Entity-marker documents
             # bridge each child for the marker split — the
@@ -2539,15 +2636,67 @@ module Moxml
                CustomizedLeptris::EntityReference, CustomizedLeptris::TextSegment,
                # Terminal node kinds pay an FFI round trip for an empty
                # list; unfiltered recursions visit every text node.
+               # Address tokens of the terminal kinds (text, comment,
+               # cdata, pi) have no children either.
                ::Leptris::XML::Text, ::Leptris::XML::Comment,
                ::Leptris::XML::CDATA, ::Leptris::XML::ProcessingInstruction,
-               ::Leptris::XML::Attr
+               ::Leptris::XML::Attr, AddressNode
             []
           else
             node.children.to_a
           end
         end
 
+        # The address-native arm's child list: one children_addrs
+        # crossing, one token per child (ADDRESS_NATIVES cache for
+        # identity stability).
+        ADDRESS_NATIVES = :address_natives
+
+        def address_children(doc, node)
+          addrs, kinds = ::Leptris::XML::Native.children_addrs(
+            node.is_a?(AddressNode) ? node.address : node,
+          )
+          children = Array.new(addrs.size)
+          i = 0
+          while i < addrs.size
+            children[i] = address_native(doc, addrs[i], kinds[i])
+            i += 1
+          end
+          children
+        end
+
+        # One address token per (document version, address): the
+        # context registry keys wrapper identity on the token, so a
+        # stable token per address keeps the children[0].equal?
+        # semantics across traversals. The document version stamps
+        # the map — any mutation invalidates wholesale, the same
+        # discipline as the columnar map and the binding's own
+        # children memo.
+        ADDRESS_NATIVES_CAP = 1_048_576
+
+        def address_native(doc, address, kind)
+          pair = attachments.get(doc, ADDRESS_NATIVES)
+          unless pair.is_a?(Array) && pair[0] == doc.version
+            pair = [doc.version, {}]
+            attachments.set(doc, ADDRESS_NATIVES, pair)
+          end
+          map = pair[1]
+          map.clear if map.size >= ADDRESS_NATIVES_CAP
+          token = map[address]
+          return token if token
+
+          token = AddressNode.new(doc, address, kind)
+          map[address] = token
+          token
+        end
+
+        # Element-ness of a native receiver, for the address arm's
+        # gate (one kind read; the token lane answers from the
+        # parent-reported kind without a crossing).
+        def element_native?(node)
+          NN_NODE_TYPE.bind_call(node) == :element
+        end
+
         # Map hit for a primed node (see COLUMNAR_WALK). Served dup'd so
         # no consumer can mutate the cached list in place.
         def columnar_children_hit(node)
@@ -2737,6 +2886,24 @@ module Moxml
         def root_parent(node)
           return node.document if node.is_a?(::Leptris::XML::DocType)
 
+          # Address tokens carry no parent face: bridge once, then
+          # answer through the binding parent — as a document-cache
+          # twin so the answer stays in the native representation.
+          # The binding reports the root element and document-level
+          # parts parentless; the moxml contract roots them at the
+          # document (same rule as the binding arm below).
+          if node.is_a?(AddressNode)
+            doc = node.document
+            bound = to_binding(node)
+            parent = bound&.parent
+            return native_twin(doc, parent) if parent
+
+            return doc if doc && (doc.root&.c_address == node.address ||
+              bound.is_a?(::Leptris::XML::ProcessingInstruction))
+
+            return nil
+          end
+
           parent = node.parent
           return parent if parent
 
@@ -2750,6 +2917,8 @@ module Moxml
         end
 
         def next_sibling(node)
+          return next_sibling(to_binding(node)) if node.is_a?(AddressNode)
+
           return NN_NEXT_SIBLING.bind_call(node) if NATIVE_READ_LAYER &&
             node.is_a?(::Leptris::XML::NativeNode)
 
@@ -2766,6 +2935,8 @@ module Moxml
         end
 
         def document(node)
+          return node.document if node.is_a?(AddressNode)
+
           return doc_for(node) if NATIVE_READ_LAYER &&
             node.is_a?(::Leptris::XML::NativeNode)
 
@@ -2792,8 +2963,6 @@ module Moxml
         end
 
         def source_position(node)
-          return nil unless NATIVE_SOURCE_POSITION
-
           to_binding(node).source_position
         end
 
@@ -2919,7 +3088,9 @@ module Moxml
         end
 
         def attr_packet_target(element)
-          if NATIVE_READ_LAYER && element.is_a?(NN)
+          if element.is_a?(AddressNode)
+            [element.document, element.address]
+          elsif NATIVE_READ_LAYER && element.is_a?(NN)
             [NN_DOCUMENT.bind_call(element), element.address]
           elsif element.respond_to?(:c_address)
             [element.document, element.c_address]
@@ -3738,6 +3909,22 @@ module Moxml
         end
 
         def text_content(node)
+          # Address tokens dispatch the same kind table the native
+          # layer's #content uses (elements aggregate via
+          # fast_element_text; text/comment/cdata/pi carry their
+          # payload faces).
+          if node.is_a?(AddressNode)
+            native = ::Leptris::XML::Native
+            content = case node.kind
+                      when 0 then native.fast_element_text(node.address)
+                      when 1 then native.fast_text_content(node.address)
+                      when 2 then native.fast_comment_content(node.address)
+                      when 3 then native.fast_cdata_content(node.address)
+                      when 4 then native.fast_pi_data(node.address)
+                      end
+            return content.to_s
+          end
+
           if NATIVE_READ_LAYER && node.is_a?(::Leptris::XML::NativeNode)
             content = NN_CONTENT.bind_call(node)
             return content if NATIVE_STRINGS_UTF8
@@ -3833,6 +4020,10 @@ module Moxml
         end
 
         def cdata_content(node)
+          if node.is_a?(AddressNode)
+            return ::Leptris::XML::Native.fast_cdata_content(node.address)
+          end
+
           return NN_CONTENT.bind_call(node) if NATIVE_READ_LAYER && node.is_a?(NN)
 
           node.content
@@ -3844,6 +4035,10 @@ module Moxml
         end
 
         def comment_content(node)
+          if node.is_a?(AddressNode)
+            return ::Leptris::XML::Native.fast_comment_content(node.address)
+          end
+
           if NATIVE_READ_LAYER && node.is_a?(NN)
             content = NN_CONTENT.bind_call(node)
             # NativeNode#content answers nil for comment-kind nodes
@@ -4220,7 +4415,7 @@ module Moxml
             # (leptris-ruby#153: ResultAttr wrappers with name/value);
             # older bindings returned generic Node wrappers whose
             # #name raised, so the Ruby engine owned them.
-            next true if selects_attribute_results?(ast) && ATTR_RESULT_NATIVE
+            next true if selects_attribute_results?(ast)
 
             !selects_attribute_results?(ast)
           end
@@ -4331,14 +4526,14 @@ module Moxml
         def sax_parse(xml, handler)
           bridge = LeptrisSAXBridge.new(handler)
           xml_string = xml.is_a?(IO) || xml.is_a?(::StringIO) ? xml.read : xml.to_s
-          # Bulk record drain (leptris#1298, NATIVE_SAX_RECORDS):
+          # Bulk record drain (leptris#1298):
           # one crossing per document. The handler decides the shape
           # polymorphically — Handler#on_sax_records answers
           # :unhandled, so classic handlers get the exact callback
           # stream replayed from the table; hot loops override and
           # walk the records (nil table = outside the drain subset
           # or pre-1.9.238 binding — callback path).
-          table = NATIVE_SAX_RECORDS ? ::Leptris::XML::SAX::Records.open(xml_string) : nil
+          table = ::Leptris::XML::SAX::Records.open(xml_string)
           if table
             begin
               return if handler.on_sax_records(table) != :unhandled

data/lib/moxml/context.rb

@@ -237,14 +237,13 @@ module Moxml
     # Compile an XSD schema from a file path — <xs:include href>
     # resolves relative to the file's directory (the engine
     # resolves it; reading the file into #xsd would lose that).
-    # The #452 rule index reads this document only; a document
-    # that composes others (include/import/redefine/override)
-    # turns the strict re-checks off (#510) — included parts stay
-    # engine-validated and the index can only under-report.
+    # The path is kept on the Schema (moxml#522): #validate resolves
+    # the instance's xsi:schemaLocation hints against it and unions
+    # the hinted documents into the compiled set.
     def xsd_file(path)
       handle = config.adapter.xsd_compile_file(path.to_s)
       source = File.read(path.to_s)
-      Moxml::XSD::Schema.new(handle, self, source)
+      Moxml::XSD::Schema.new(handle, self, source, path: path.to_s)
     end
 
     # Compile a SET of schema documents (paths) into one schema:

data/lib/moxml/version.rb

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