moxml 0.5.176 → 0.5.178

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b00ba396700e1ee797651d8db90cc283733f062021e05d8c807c751a07442414
-  data.tar.gz: f0f35b75c740842a6bb4a21c0fde3b944e5994c2935a1de0e57b6671d02eb2fe
+  metadata.gz: ab4976a5d2b2a909d73204d71c0c6d67285ab3e1fd9c53db7bffc00e39425cca
+  data.tar.gz: a7d948364c456db7f8201b62a807758121d28d9635326eb91d68c43f499ff81f
 SHA512:
-  metadata.gz: 8302fa56d49d9e6965559bf2be0db79afc61b5d6696cbe34aa5f6ff07381af94261b2988f858d76d5625cb7796b84c70999a6e899e7d5b5c61cdd58134dba462
-  data.tar.gz: 349a9bf1e50540698ee21572f29c93db127d206bca9ab622fed3c989ed601af0109181b9b107ac06c27f17432cf98402ab2118d3ba6f8b0976b8ee7542fd74d8
+  metadata.gz: 2b1ff2e8c6dcb6d25e6b07270f3234a8ce7daf7475544b63f070405645c423f241e0212b4260ad688c1cb7433d8bc2ea7d1e3f4a0a14e9dcf4a67e832d53ee01
+  data.tar.gz: bf6c389706fb4d28e07af24a4d81bdacf0e4823d9bac95ea2f0ce7f55b08277cdcf8aa800424125a937fb3bf2be603b336b165f01aa9a9048277178357c4471d

data/lib/moxml/adapter/leptris.rb

@@ -341,6 +341,17 @@ module Moxml
         # (Leptris::VERSION), +engine_version+ is libleptris's own
         # (the leptris_version() C face, face-probed — nil on a
         # binding without it).
+        #
+        # Support faces are DESCRIPTOR-AUTHORITATIVE (leptris-ruby#572
+        # bridge, engine leptris#1905): a face answers true only when
+        # the ENGINE's capability bitset serves it AND the binding
+        # exposes it — a face the engine serves but the binding has
+        # not bridged is indistinguishable from absent without the
+        # bitset. On a binding without the bridge the probe answer
+        # stands alone (never narrowed by missing data). The bit
+        # values decode the engine's LEPTRIS_CAP_* layout (bits
+        # append per the engine's contract; the binding re-encodes
+        # nothing, the model names them).
         def capabilities
           @capabilities ||= {
             binding_version: ::Leptris::VERSION,
@@ -353,17 +364,44 @@ module Moxml
             add_element_full: ADD_ELEMENT_FULL,
             native_strings_utf8: !NATIVE_STRINGS_UTF8.nil?,
             native_mutations_coherent: !NATIVE_MUTATIONS_COHERENT.nil?,
-            native_entity_refs: !NATIVE_ENTITY_REFS.nil?,
+            native_entity_refs:
+              !NATIVE_ENTITY_REFS.nil? && engine_serves?(:entity_ref_nodes),
             native_bulk_fixed: !NATIVE_BULK_FIXED.nil?,
             native_plan_structs: NATIVE_PLAN_STRUCTS,
             native_plan_typed: NATIVE_PLAN_TYPED,
-            digest: DIGEST_SUPPORTED,
-            xsd: XSD_SUPPORTED,
-            relaxng: RELAXNG_SUPPORTED,
-            xslt: XSLT_SUPPORTED,
+            digest: DIGEST_SUPPORTED && engine_serves?(:digest),
+            xsd: XSD_SUPPORTED && engine_serves?(:xsd),
+            relaxng: RELAXNG_SUPPORTED && engine_serves?(:relaxng),
+            xslt: XSLT_SUPPORTED && engine_serves?(:xslt),
           }.freeze
         end
 
+        # The engine's capability descriptor (raw bitset), or nil on
+        # a binding without the bridge. The bit values are the
+        # engine's LEPTRIS_CAP_* layout at descriptor version 1 —
+        # bits append, so the decode stays valid on later sets.
+        ENGINE_CAPS_BITS = {
+          digest: 1 << 9,
+          xsd: 1 << 10,
+          relaxng: 1 << 12,
+          xslt: 1 << 14,
+          entity_ref_nodes: 1 << 24,
+        }.freeze
+
+        def engine_serves?(face)
+          descriptor = engine_descriptor
+          return true unless descriptor
+
+          descriptor[:caps].anybits?(ENGINE_CAPS_BITS.fetch(face))
+        end
+
+        def engine_descriptor
+          @engine_descriptor ||=
+            if defined?(::Leptris::XML.capabilities)
+              ::Leptris::XML.capabilities
+            end
+        end
+
         # 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

data/lib/moxml/context.rb

@@ -214,9 +214,10 @@ 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; included
-    # schema parts stay engine-validated (the index can only
-    # under-report).
+    # 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.
     def xsd_file(path)
       handle = config.adapter.xsd_compile_file(path.to_s)
       source = File.read(path.to_s)
@@ -229,7 +230,10 @@ module Moxml
     # types) are visible to the head's content models — the
     # single-document faces cannot see them (#483 item 4). The
     # Schema's #version / SchemaRules index read the HEAD document
-    # (the first path); engine-set semantics cover the rest.
+    # (the first path); engine-set semantics cover the rest. A set
+    # is composition-shaped by contract, so the strict re-checks
+    # stay off (#510): the index under-reports instead of
+    # false-reporting components that live in a member.
     # Adapters without a set-capable engine raise
     # Moxml::NotImplementedError.
     def xsd_set(*paths)
@@ -238,7 +242,7 @@ module Moxml
 
       handle = config.adapter.xsd_compile_set(paths.map(&:to_s))
       source = File.read(paths.first.to_s)
-      Moxml::XSD::Schema.new(handle, self, source)
+      Moxml::XSD::Schema.new(handle, self, source, self_contained: false)
     end
 
     # Compile a RELAX NG schema from source or from a file path (the

data/lib/moxml/version.rb

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

data/lib/moxml/xsd/schema_rules.rb

@@ -197,7 +197,7 @@ module Moxml
                                :attribute_default, :elements,
                                :attributes, :contents, :version,
                                :element_patterns, :attribute_patterns,
-                               :substitution_members)
+                               :substitution_members, :self_contained)
 
       # Resolves a QName token against an element's in-scope
       # bindings. node.namespaces is adapter-divergent (some
@@ -338,7 +338,7 @@ module Moxml
         # Index one schema document. Returns nil when the source
         # cannot be indexed — the engine's answer then stands alone
         # (today's behavior).
-        def index(schema_source, context)
+        def index(schema_source, context, self_contained: nil)
           root = context.parse(schema_source).root
           return nil unless root&.name == "schema"
 
@@ -346,7 +346,8 @@ module Moxml
             root["targetNamespace"].to_s,
             root["elementFormDefault"] == "qualified",
             root["attributeFormDefault"] == "qualified",
-            {}, {}, {}, schema_version(root), {}, {}, {}
+            {}, {}, {}, schema_version(root), {}, {}, {},
+            self_contained.nil? ? composition_free?(root) : self_contained
           )
           child_elements(root).each do |decl|
             case decl.name
@@ -360,6 +361,24 @@ module Moxml
           nil
         end
 
+        COMPOSITION_ELEMENTS = %w[include import redefine override].freeze
+
+        # A schema document that composes other documents
+        # (include/import/redefine/override) declares only part of
+        # the compiled declaration surface in its own source — the
+        # engine resolves the members, and a strict re-check run
+        # against this index alone would answer "not declared" for
+        # components that live in a member (#510): a false report,
+        # which the one-directional contract forbids. Composition
+        # therefore turns the strict re-checks off — the index
+        # under-reports instead. Schema sets (xsd_set) are always
+        # composition-shaped: any member may carry declarations.
+        def composition_free?(root)
+          child_elements(root).none? do |decl|
+            COMPOSITION_ELEMENTS.include?(decl.name)
+          end
+        end
+
         # The effective schema version declared at the root
         # (#460 item 2): vc:minVersion="1.1" on <xs:schema> scopes
         # the document to 1.1 semantics; anything else reports
@@ -606,12 +625,18 @@ module Moxml
           model = index.contents[root_qname]
           findings = []
           findings << nil_finding(root, declaration) if declaration
-          findings.concat(attribute_findings(root, model, index))
-          if model
+          # The strict wildcard/attribute re-checks answer "not
+          # declared" against this index's declaration sets — they
+          # vouch only when the index saw the whole declaration
+          # surface (no composition, #510).
+          if model && index.self_contained
             child_elements(root).each do |child|
               findings.concat(child_findings(child, model, index))
             end
           end
+          if index.self_contained
+            findings.concat(attribute_findings(root, model, index))
+          end
           findings.compact
         end
 

data/lib/moxml/xsd.rb

@@ -96,11 +96,15 @@ module Moxml
               "schema released (deterministic drop); compile a new one"
       end
 
-      def initialize(handle, context, schema_source = nil)
+      def initialize(handle, context, schema_source = nil,
+                     self_contained: nil)
         @handle = handle
         @context = context
         @rules_index =
-          schema_source && SchemaRules.index(schema_source, context)
+          if schema_source
+            SchemaRules.index(schema_source, context,
+                              self_contained: self_contained)
+          end
         assert_adapter_matches_handle!
       end
 

data/spec/moxml/adapter_capabilities_spec.rb

@@ -52,6 +52,31 @@ RSpec.describe "engine capability report" do
     expect(caps[:xslt]).to be(true)
   end
 
+  # leptris-ruby#572: the binding bridges the engine's capability
+  # descriptor, and the support faces answer its verdict ANDed with
+  # the binding probe — a face the engine serves but the binding has
+  # not bridged is not "true" (the half-face trap the version-gate
+  # class could not see).
+  it "answers the support faces from the engine descriptor bitset" do
+    skip "requires the binding's descriptor bridge (leptris 1.9.396+)" unless
+      defined?(Leptris::XML.capabilities)
+
+    caps = Moxml::Adapter::Leptris.capabilities
+    descriptor = Leptris::XML.capabilities
+    expect(descriptor[:descriptor_version]).to be(1)
+    {
+      digest: 1 << 9,
+      xsd: 1 << 10,
+      relaxng: 1 << 12,
+      xslt: 1 << 14,
+    }.each do |face, bit|
+      served = descriptor[:caps].anybits?(bit)
+      expect(caps[face]).to eql(served),
+                            "#{face} must answer the engine bitset's verdict " \
+                            "(ANDed with the binding probe)"
+    end
+  end
+
   it "is memoized — repeated queries answer the same frozen object" do
     expect(Moxml::Adapter::Leptris.capabilities)
       .to equal(Moxml::Adapter::Leptris.capabilities)

data/spec/moxml/xsd_set_spec.rb

@@ -82,6 +82,84 @@ RSpec.describe "Schema-set compilation" do
     end
   end
 
+  # #510: the strict re-check answers "not declared" against the
+  # head document's own declaration index; composition (a set, or a
+  # single document carrying include/import/redefine/override)
+  # means declarations may live in a member the index never saw —
+  # the re-check must stay silent (under-report, never
+  # false-report) and let the engine's set-wide answer stand.
+  describe "strict re-check across composed schemas (#510)" do
+    def write_wildcard_set(dir)
+      File.write(File.join(dir, "headw.xsd"), <<~XSD)
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                   xmlns="urn:W" targetNamespace="urn:W">
+          <xs:import namespace="urn:D" schemaLocation="decl.xsd"/>
+          <xs:element name="foo">
+            <xs:complexType>
+              <xs:sequence>
+                <xs:any namespace="##other" processContents="strict"/>
+              </xs:sequence>
+            </xs:complexType>
+          </xs:element>
+        </xs:schema>
+      XSD
+      File.write(File.join(dir, "decl.xsd"), <<~XSD)
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                   xmlns="urn:D" targetNamespace="urn:D">
+          <xs:element name="bar" type="xs:string"/>
+        </xs:schema>
+      XSD
+      [File.join(dir, "headw.xsd"), File.join(dir, "decl.xsd")]
+    end
+
+    def wildcard_instance
+      '<foo xmlns="urn:W" xmlns:d="urn:D"><d:bar>hi</d:bar></foo>'
+    end
+
+    it "does not false-report a member-declared admission on a set" do
+      skip "requires the leptris compile_set face (binding 1.9.386.0+)" unless
+        set_capable?
+
+      Dir.mktmpdir do |dir|
+        paths = write_wildcard_set(dir)
+        schema = ctx.xsd_set(*paths)
+        expect(schema.validate(wildcard_instance)).to be_empty
+      end
+    end
+
+    it "does not false-report on a single composing document" do
+      Dir.mktmpdir do |dir|
+        write_wildcard_set(dir)
+        schema = ctx.xsd_file(File.join(dir, "headw.xsd"))
+        expect(schema.validate(wildcard_instance)).to be_empty
+      end
+    end
+
+    it "keeps the re-check on a self-contained schema" do
+      Dir.mktmpdir do |dir|
+        path = File.join(dir, "solo.xsd")
+        File.write(path, <<~XSD)
+          <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                     xmlns="urn:S" targetNamespace="urn:S">
+            <xs:element name="solo">
+              <xs:complexType>
+                <xs:sequence>
+                  <xs:any namespace="##other" processContents="strict"/>
+                </xs:sequence>
+              </xs:complexType>
+            </xs:element>
+          </xs:schema>
+        XSD
+        schema = ctx.xsd_file(path)
+        errors = schema.validate(
+          '<solo xmlns="urn:S"><u:x xmlns:u="urn:U"/></solo>',
+        )
+        expect(errors.first.message)
+          .to include("matches a strict wildcard but is not declared")
+      end
+    end
+  end
+
   it "raises on an empty set" do
     expect { ctx.xsd_set }.to raise_error(ArgumentError)
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.176
+  version: 0.5.178
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-30 00:00:00.000000000 Z
+date: 2026-10-31 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API