moxml 0.5.176 → 0.5.177

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b00ba396700e1ee797651d8db90cc283733f062021e05d8c807c751a07442414
-  data.tar.gz: f0f35b75c740842a6bb4a21c0fde3b944e5994c2935a1de0e57b6671d02eb2fe
+  metadata.gz: 021a0d5d25cfe9e12a0a29968649a0801d0379e30b4f6aefe349d86a8959149b
+  data.tar.gz: 197a8e2c303f7fa1e29e7f25b8d64502d6c3d3179ca342af4b02dda168e7fa89
 SHA512:
-  metadata.gz: 8302fa56d49d9e6965559bf2be0db79afc61b5d6696cbe34aa5f6ff07381af94261b2988f858d76d5625cb7796b84c70999a6e899e7d5b5c61cdd58134dba462
-  data.tar.gz: 349a9bf1e50540698ee21572f29c93db127d206bca9ab622fed3c989ed601af0109181b9b107ac06c27f17432cf98402ab2118d3ba6f8b0976b8ee7542fd74d8
+  metadata.gz: cddcf3bb2b304e5d78779cba12b3f57514b783336642a8e40ca7d8894ba47485ef6ffff114b9f8a1430e6b9669067c86f4de2bbd53aac6d18ed8ffef52828d5f
+  data.tar.gz: 6d88eb872c4a876d9f387af3e006eb8247935ff58f70c6d3249d6b3afba7809e3485c117fbeaa3dc61103ab9858997b98c230efc870e0dac0a914971bb20e49e

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.177"
 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/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,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.176
+  version: 0.5.177
 platform: ruby
 authors:
 - Ribose Inc.