RubyGems - moxml - Versions diffs - 0.5.157 → 0.5.159 - Mend

moxml 0.5.157 → 0.5.159

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (12) hide show

checksums.yaml +4 -4
data/.github/workflows/performance-release.yml +24 -8
data/benchmark/README.md +10 -10
data/benchmark/scoreboard.json +38 -38
data/docs/_pages/performance.adoc +13 -15
data/lib/moxml/adapter/leptris.rb +34 -0
data/lib/moxml/context.rb +6 -2
data/lib/moxml/version.rb +1 -1
data/lib/moxml/xsd/schema_rules.rb +335 -0
data/lib/moxml/xsd.rb +15 -2
data/spec/moxml/xsd_underdetection_spec.rb +174 -0
metadata +4 -2

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 87300d8760e99b65ddda1dd2163c09eeef602885700b8bf7159ee8cb06f708f5
-  data.tar.gz: 2bcf6f9deb2fd3bef73234ca9d2e9cac11771efc37e8339ecd2cbc82a2a9cb15
+  metadata.gz: 824fc75872bed077049fca259a7b667634c2938e4a22c3899d7c898a0a585c98
+  data.tar.gz: f639f83b2c39247bb825ce017932ada226d9fb8b11ad6567893f1cb00babaa7f
 SHA512:
-  metadata.gz: bfa9a5c9582fc99bae9aed8888c653ce3bdca81a3a5a3b32ed5be598eea5f0900793d9ef1f453cf8185a6838912a4f6393ae43038f1db2e6a9d1ca3a99c34dd6
-  data.tar.gz: e07cd31013b48ec143ef5840097c32cba6f00dff10141ca6f2e6371c98bde6ab98bdf920dc1e8701d5d2bea26d961d09d5c35d3229864beffa26e5066dc98e7c
+  metadata.gz: eca084853becfa0d0dfaa80e88f492f1d4541e32a97aed2480f441db3bd33990d7c0f6ab2879db8aa9fb92216bcc6782afa573384e4126724801f38094a53c99
+  data.tar.gz: 6429a255c098e7291fd45b0034d23abbe7a3acc1fccbdb9956f1ac2e3002890415388d3e060b1d20869d3783d38f986917e633597b8e05dcd3b3effffc9e7cf6

data/.github/workflows/performance-release.yml CHANGED Viewed

@@ -3,12 +3,23 @@ name: performance-release
 # Every release re-measures the scoreboard and appends the table to
 # the release notes (TODO.sota/04). Triggered by the release
 # workflow's completion; idempotent — a re-run replaces the marked
-# section instead of stacking it.
+# section instead of stacking it. Manual dispatch can backfill any
+# release: `ref` pins the measured tree, `tag` pins the notes
+# target (both default to the automatic release-run behavior).
 on:
   workflow_run:
     workflows: ["release"]
     types: [completed]
   workflow_dispatch:
+    inputs:
+      ref:
+        description: "Tree to measure (branch/tag/SHA); default: the released tree"
+        required: false
+        type: string
+      tag:
+        description: "Release whose notes receive the section; default: the triggering release"
+        required: false
+        type: string
 concurrency:
   group: ${{ github.workflow }}
@@ -30,8 +41,9 @@ jobs:
         with:
           # Pin to the exact tree the release run published, so the
           # measured scoreboard describes the released code even when
-          # main moves between the release and this report.
-          ref: ${{ github.event.workflow_run.head_sha || 'main' }}
+          # main moves between the release and this report. A manual
+          # dispatch may pin any tree (backfills).
+          ref: ${{ inputs.ref || github.event.workflow_run.head_sha || 'main' }}
           submodules: "recursive"
       - name: Set up Ruby
@@ -99,11 +111,15 @@ jobs:
           # run — NOT "latest" (a rerun of an old run would mis-aim)
           # and NOT the gemspec at the pinned tree (the checkout is
           # the pre-bump tree; the bump lands on main during the
-          # release run itself).
-          TRIGGERED_AT="${{ github.event.workflow_run.created_at }}"
-          TAG=$(gh api "repos/${GITHUB_REPOSITORY}/releases" \
-            --jq "map(select(.created_at >= \"${TRIGGERED_AT}\")) | sort_by(.created_at) | last | .tag_name")
-          TAG=${TAG:-$(gh release view --json tagName --jq .tagName)}
+          # release run itself). A manual dispatch may pin the tag
+          # directly (backfills).
+          TAG="${{ inputs.tag }}"
+          if [ -z "$TAG" ]; then
+            TRIGGERED_AT="${{ github.event.workflow_run.created_at }}"
+            TAG=$(gh api "repos/${GITHUB_REPOSITORY}/releases" \
+              --jq "map(select(.created_at >= \"${TRIGGERED_AT}\")) | sort_by(.created_at) | last | .tag_name")
+            TAG=${TAG:-$(gh release view --json tagName --jq .tagName)}
+          fi
           echo "Reporting against $TAG"
           gh release view "$TAG" --json body --jq .body > /tmp/body.md
           ruby -e '

data/benchmark/README.md CHANGED Viewed

@@ -92,16 +92,16 @@ rewrites this block and `docs/_pages/performance.adoc`):
 <!-- SCOREBOARD:BEGIN -->
 | Row | Ratio | Kind | Status |
 | --- | ----- | ---- | ------ |
-| `parse` | 4.62x | parity | met |
-| `serialize` | 1.72x | parity | met |
-| `xpath //field (count)` | 0.70x | structural | tracked (below parity) |
-| `xpath //field (each)` | 0.36x | structural | tracked (below parity) |
-| `attr pairs listing` | 7.92x | parity | met |
-| `build add_element` | 0.60x | structural | tracked (below parity) |
-| `walk+read (warm)` | 0.54x | structural | tracked (below parity) |
-| `walk+read (cold)` | 0.21x | structural | tracked (below parity) |
-| `children recursion (cold)` | 0.18x | structural | tracked (below parity) |
-| `plan records (typed)` | 1.13x | data | informational |
+| `parse` | 3.59x | parity | met |
+| `serialize` | 1.83x | parity | met |
+| `xpath //field (count)` | 4.79x | parity | met |
+| `xpath //field (each)` | 0.44x | structural | tracked (below parity) |
+| `attr pairs listing` | 7.46x | parity | met |
+| `build add_element` | 0.57x | structural | tracked (below parity) |
+| `walk+read (warm)` | 0.64x | structural | tracked (below parity) |
+| `walk+read (cold)` | 0.17x | structural | tracked (below parity), paused: leptris-ruby#527 (1.9.380 crossing regression) |
+| `children recursion (cold)` | 0.13x | structural | tracked (below parity), paused: leptris-ruby#527 (1.9.380 crossing regression) |
+| `plan records (typed)` | 1.14x | data | informational |
 <!-- SCOREBOARD:END -->
 The open rows are the known structural gap: every node the facade

data/benchmark/scoreboard.json CHANGED Viewed

@@ -1,23 +1,23 @@
 {
   "protocol": {
-    "measured": "2026-10-22T09:33:49Z",
-    "ruby": "3.3.12",
+    "measured": "2026-10-23T15:54:45Z",
+    "ruby": "3.3.13",
     "adapter": "leptris",
-    "adapter_version": "1.9.380.1",
+    "adapter_version": "1.9.381.0",
     "nokogiri": "1.19.4",
     "reps": 9,
     "warmup": 2,
     "clock": "CLOCK_PROCESS_CPUTIME_ID",
-    "load": 1.81
+    "load": 1.87
   },
   "rows": [
     {
       "row": "parse",
       "kind": "parity",
       "parity": true,
-      "baseline_us": 1051.8,
-      "candidate_us": 227.7,
-      "ratio": 4.619,
+      "baseline_us": 1027.8,
+      "candidate_us": 286.6,
+      "ratio": 3.586,
       "baseline_allocs": 7,
       "candidate_allocs": 18
     },
@@ -25,39 +25,39 @@
       "row": "serialize",
       "kind": "parity",
       "parity": true,
-      "baseline_us": 469.2,
-      "candidate_us": 272.1,
-      "ratio": 1.724,
+      "baseline_us": 517.0,
+      "candidate_us": 281.9,
+      "ratio": 1.834,
       "baseline_allocs": 30,
       "candidate_allocs": 14
     },
     {
       "row": "xpath //field (count)",
-      "kind": "structural",
-      "parity": false,
-      "baseline_us": 69.1,
-      "candidate_us": 98.0,
-      "ratio": 0.705,
+      "kind": "parity",
+      "parity": true,
+      "baseline_us": 121.9,
+      "candidate_us": 25.4,
+      "ratio": 4.791,
       "baseline_allocs": 13,
-      "candidate_allocs": 3
+      "candidate_allocs": 8
     },
     {
       "row": "xpath //field (each)",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 263.3,
-      "candidate_us": 734.3,
-      "ratio": 0.359,
+      "baseline_us": 361.9,
+      "candidate_us": 822.7,
+      "ratio": 0.44,
       "baseline_allocs": 1213,
-      "candidate_allocs": 4
+      "candidate_allocs": 10
     },
     {
       "row": "attr pairs listing",
       "kind": "parity",
       "parity": true,
-      "baseline_us": 488.8,
-      "candidate_us": 61.7,
-      "ratio": 7.92,
+      "baseline_us": 502.0,
+      "candidate_us": 67.3,
+      "ratio": 7.458,
       "baseline_allocs": 3300,
       "candidate_allocs": 0
     },
@@ -65,9 +65,9 @@
       "row": "build add_element",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 5572.7,
-      "candidate_us": 9372.9,
-      "ratio": 0.595,
+      "baseline_us": 5532.8,
+      "candidate_us": 9658.2,
+      "ratio": 0.573,
       "baseline_allocs": 20358,
       "candidate_allocs": 11363
     },
@@ -75,9 +75,9 @@
       "row": "walk+read (warm)",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 1548.6,
-      "candidate_us": 2867.0,
-      "ratio": 0.54,
+      "baseline_us": 1805.4,
+      "candidate_us": 2797.9,
+      "ratio": 0.645,
       "baseline_allocs": 4503,
       "candidate_allocs": 2
     },
@@ -85,9 +85,9 @@
       "row": "walk+read (cold)",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 2913.9,
-      "candidate_us": 13771.8,
-      "ratio": 0.212,
+      "baseline_us": 2938.6,
+      "candidate_us": 17354.2,
+      "ratio": 0.169,
       "baseline_allocs": 6011,
       "candidate_allocs": 10232
     },
@@ -95,9 +95,9 @@
       "row": "children recursion (cold)",
       "kind": "structural",
       "parity": false,
-      "baseline_us": 3381.3,
-      "candidate_us": 18658.1,
-      "ratio": 0.181,
+      "baseline_us": 3346.5,
+      "candidate_us": 25949.4,
+      "ratio": 0.129,
       "baseline_allocs": 5711,
       "candidate_allocs": 8732
     },
@@ -105,9 +105,9 @@
       "row": "plan records (typed)",
       "kind": "data",
       "parity": false,
-      "baseline_us": 3063.0,
-      "candidate_us": 2721.5,
-      "ratio": 1.126,
+      "baseline_us": 2901.1,
+      "candidate_us": 2554.9,
+      "ratio": 1.136,
       "baseline_allocs": 8112,
       "candidate_allocs": 13232
     }

data/docs/_pages/performance.adoc CHANGED Viewed

@@ -12,28 +12,26 @@ the marked block below from a live measurement; see
 `benchmark/README.md` for the protocol and row definitions.
 // SCOREBOARD:BEGIN
-Generated from the gate-passed CI measurement (pinned ubuntu-24.04, settled runner, `benchmark:lock`). Protocol: CPU-time medians of an interleaved A/B run (raw nokogiri vs moxml on leptris); the ratio is baseline / candidate, so > 1.0 means the facade is faster. Warmups discarded, GC between samples.
+Generated by `SCORE_PUBLISH=1 bundle exec ruby benchmark/scoreboard.rb`. Protocol: CPU-time medians of an interleaved A/B run (raw nokogiri vs moxml on leptris); the ratio is baseline / candidate, so > 1.0 means the facade is faster. Warmups discarded, GC between samples.
-Measurement: Ruby 3.3.12, leptris leptris 1.9.380.1, nokogiri 1.19.4, 2026-10-22T09:33:49Z, 1-minute load 1.81, 9 repetitions.
+Measurement: Ruby 3.3.13, leptris 1.9.381.0, nokogiri 1.19.4, 2026-10-23T15:54:45Z, 1-minute load 1.87, 9 repetitions.
 [cols="2,1,1,1",options="header"]
 |===
 | Row | Ratio | Kind | Status
-| `parse` | 4.62x | parity | met
-| `serialize` | 1.72x | parity | met
-| `xpath //field (count)` | 0.70x | structural | tracked (below parity)
-| `xpath //field (each)` | 0.36x | structural | tracked (below parity)
-| `attr pairs listing` | 7.92x | parity | met
-| `build add_element` | 0.60x | structural | tracked (below parity)
-| `walk+read (warm)` | 0.54x | structural | tracked (below parity)
-| `walk+read (cold)` | 0.21x | structural | tracked (below parity)
-| `children recursion (cold)` | 0.18x | structural | tracked (below parity)
-| `plan records (typed)` | 1.13x | data | informational
+| `parse` | 3.59x | parity | met
+| `serialize` | 1.83x | parity | met
+| `xpath //field (count)` | 4.79x | parity | met
+| `xpath //field (each)` | 0.44x | structural | tracked (below parity)
+| `attr pairs listing` | 7.46x | parity | met
+| `build add_element` | 0.57x | structural | tracked (below parity)
+| `walk+read (warm)` | 0.64x | structural | tracked (below parity)
+| `walk+read (cold)` | 0.17x | structural | tracked (below parity), paused: leptris-ruby#527 (1.9.380 crossing regression)
+| `children recursion (cold)` | 0.13x | structural | tracked (below parity), paused: leptris-ruby#527 (1.9.380 crossing regression)
+| `plan records (typed)` | 1.14x | data | informational
 |===
-*Parity rows* must stay at or above the 0.95 measurement floor. *Structural rows* are measured and trend-locked (10% regression tolerance) while their gaps remain open. *Data API* rows are informational.
-NOTE: the 1.9.380 engine line regressed the crossing-bound rows ~2x (and the XPath evaluator itself) against 1.9.37x — tracked as leptris-ruby#527; this baseline records the 380.1 reality the lock now guards.
+*Parity rows* must stay at or above the 0.95 measurement floor. *Structural rows* are measured and trend-locked (10% regression tolerance) while their gaps remain open: per-node wrapper minting costs (#312 endgame) and engine construction. *Data API* rows are informational.
 // SCOREBOARD:END
 === Memory management

data/lib/moxml/adapter/leptris.rb CHANGED Viewed

@@ -555,6 +555,11 @@ module Moxml
             # face is a C method at 50-84ns).
             ELEMENT = Class.new(::Leptris::XML::NativeNode) do
               alias_method :native_name, :name
+              # The C nn_document (the BINDING document handle) is
+              # captured before Moxml::Node#document shadows it —
+              # the construction fast path needs the binding doc,
+              # not a facade wrapper (TODO.sota/04 bridge tax).
+              alias_method :native_document, :document
               include ::Moxml::Node
               include ::Moxml::Element
@@ -2623,6 +2628,35 @@ module Moxml
         def create_element_with_attrs(parent, name, attrs)
           drop_columnar_children(parent)
           validate_element_name(name)
+          # NativeNode parents need NO FFI twin (TODO.sota/04 bridge
+          # tax): the bridge existed only to obtain c_address +
+          # document, and the NativeNode answers both natively
+          # (address / document). The twin mint per building parent
+          # (FFI::Pointer + binding Node.wrap + registry insert) is
+          # pure construction overhead.
+          if parent.is_a?(::Leptris::XML::NativeNode)
+            doc = parent.respond_to?(:native_document) &&
+              parent.native_document or return nil
+            return nil unless ::Leptris::XML::Native.respond_to?(:create_element_with_attrs)
+            flat = attrs.flatten
+            if NATIVE_C_MINT &&
+                ::Leptris::XML::Native.respond_to?(:create_element_with_attrs_wrapped)
+              minted = ::Leptris::XML::Native.create_element_with_attrs_wrapped(
+                doc, parent.address, name.to_s, flat
+              )
+              return minted unless minted.nil?
+            end
+            addr = ::Leptris::XML::Native.create_element_with_attrs(
+              doc.c_address, parent.address, name.to_s, flat
+            )
+            return nil if addr.nil? || addr.zero?
+            return native_twin(
+              doc, ::Leptris::XML::Node.wrap(::FFI::Pointer.new(addr), doc)
+            )
+          end
           binding_parent = to_binding(parent)
           doc = binding_parent.document or return nil
           return nil unless ::Leptris::XML::Native.respond_to?(:create_element_with_attrs)

data/lib/moxml/context.rb CHANGED Viewed

@@ -207,15 +207,19 @@ module Moxml
     # @raise [Moxml::NotImplementedError] on adapters without a validator
     def xsd(schema_source)
       handle = config.adapter.xsd_compile(schema_source.to_s)
-      Moxml::XSD::Schema.new(handle, self)
+      Moxml::XSD::Schema.new(handle, self, schema_source.to_s)
     end
     # 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).
     def xsd_file(path)
       handle = config.adapter.xsd_compile_file(path.to_s)
-      Moxml::XSD::Schema.new(handle, self)
+      source = File.read(path.to_s)
+      Moxml::XSD::Schema.new(handle, self, source)
     end
     # Compile a RELAX NG schema from source or from a file path (the

data/lib/moxml/version.rb CHANGED Viewed

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

data/lib/moxml/xsd/schema_rules.rb ADDED Viewed

@@ -0,0 +1,335 @@
+# frozen_string_literal: true
+module Moxml
+  module XSD
+    # Ruby-side post-validation rules closing the tier-1
+    # under-detections tracked in #452: an engine may accept, inside
+    # its recognized scope, instances that violate
+    #
+    #   * a strict `xs:any` wildcard with an undeclared element,
+    #   * a strict `xs:anyAttribute` with an undeclared attribute,
+    #   * `xsi:nil` on an element whose declaration is not nillable.
+    #
+    # The rules run from an index of the schema SOURCE (this gem's
+    # own XML machinery — no engine involvement) and merge with the
+    # engine's findings; exact duplicates are dropped. Findings are
+    # one-directional: the index covers one schema document at
+    # tier-1's one-level content depth, so a missing piece can only
+    # under-report, never false-report — the same lax-scope posture
+    # tier-1 already has.
+    module SchemaRules
+      XSI_NS = "http://www.w3.org/2001/XMLSchema-instance"
+      # A wildcard's namespace attribute, per XML Schema
+      # Structures §3.10.2 (##any default; processContents default
+      # strict). :tns / :local are resolved against the indexed
+      # schema at check time.
+      class Wildcard
+        def initialize(value, process)
+          @process = (process || "strict").to_sym
+          case value
+          when nil, "##any", ""
+            @mode = :any
+          when "##other"
+            @mode = :other
+          else
+            @mode = :list
+            @namespaces = value.split(/\s+/).reject(&:empty?).freeze
+          end
+        end
+        def strict?
+          @process == :strict
+        end
+        def covers?(namespace)
+          case @mode
+          when :any then true
+          when :other
+            namespace != :local && namespace != :tns
+          else
+            @namespaces.any? { |entry| entry_covers?(entry, namespace) }
+          end
+        end
+        private
+        def entry_covers?(entry, namespace)
+          namespace == case entry
+                       when "##targetNamespace" then :tns
+                       when "##local" then :local
+                       else entry
+                       end
+        end
+      end
+      ContentModel = Struct.new(:declared_children, :any,
+                                :declared_attributes, :any_attribute)
+      SchemaIndex = Struct.new(:target_namespace, :element_default,
+                               :attribute_default, :elements,
+                               :attributes, :contents)
+      class << self
+        # 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)
+          root = context.parse(schema_source).root
+          return nil unless root&.name == "schema"
+          index = SchemaIndex.new(
+            root["targetNamespace"].to_s,
+            root["elementFormDefault"] == "qualified",
+            root["attributeFormDefault"] == "qualified",
+            {}, {}, {}
+          )
+          child_elements(root).each do |decl|
+            case decl.name
+            when "element" then index_global_element(decl, index)
+            when "attribute" then index_global_attribute(decl, index)
+            end
+          end
+          index
+        rescue StandardError
+          nil
+        end
+        # Post-validation findings for one instance document.
+        def findings(doc, index)
+          return [] unless index
+          root = doc.root
+          return [] unless root
+          root_qname = qname(root)
+          declaration = index.elements[root_qname]
+          model = index.contents[root_qname]
+          findings = []
+          findings << nil_finding(root, declaration) if declaration
+          findings.concat(attribute_findings(root, model, index))
+          if model
+            child_elements(root).each do |child|
+              findings.concat(child_findings(child, model, index))
+            end
+          end
+          findings.compact
+        end
+        private
+        def index_global_element(decl, index)
+          name = decl["name"] or return
+          qname = "{#{index.target_namespace}}#{name}"
+          index.elements[qname] = { nillable: decl["nillable"] == "true" }
+          type_attr = decl.attribute("type")
+          model = if type_attr.nil? || type_attr.value.empty?
+                    inline_model(decl, index)
+                  else
+                    named_model(decl, index)
+                  end
+          index.contents[qname] = model if model
+        end
+        def index_global_attribute(decl, index)
+          name = decl["name"] or return
+          index.attributes["{#{index.target_namespace}}#{name}"] = true
+        end
+        def inline_model(decl, index)
+          type_node = child_elements(decl).find do |child|
+            child.name == "complexType"
+          end
+          content_model(type_node, index) if type_node
+        end
+        # A named complexType reference, indexed only when the
+        # definition sits directly under this schema element.
+        def named_model(decl, index)
+          type_name = decl.attribute("type")&.value.to_s.split(":").last
+          return nil unless type_name
+          type_node = child_elements(decl.parent).find do |child|
+            child.name == "complexType" && child["name"] == type_name
+          end
+          content_model(type_node, index) if type_node
+        end
+        def content_model(type_node, index)
+          model = ContentModel.new([], nil, [], nil)
+          collect_model(type_node, index, model)
+          model
+        end
+        # Particle presence across the type's subtree (sequence /
+        # choice / all / complexContent wrappers flattened): we only
+        # ADD findings for strict-wildcard matches, so flattening
+        # can only under-report, never over-report. Cardinality and
+        # order stay the engine's job.
+        def collect_model(node, index, model)
+          child_elements(node).each do |child|
+            case child.name
+            when "element"
+              add_particle(child, index, model,
+                           model.declared_children)
+            when "attribute"
+              add_particle(child, index, model,
+                           model.declared_attributes)
+            when "any"
+              model.any ||= Wildcard.new(child["namespace"],
+                                         child["processContents"])
+            when "anyAttribute"
+              model.any_attribute ||=
+                Wildcard.new(child["namespace"],
+                             child["processContents"])
+            else
+              collect_model(child, index, model)
+            end
+          end
+        end
+        def add_particle(particle, index, _model, sink)
+          ref = particle["ref"]
+          name = ref&.split(":")&.last || particle["name"]
+          return unless name
+          sink << if ref
+                    "{#{index.target_namespace}}#{name}"
+                  else
+                    "{#{form_namespace(particle, index)}}#{name}"
+                  end
+        end
+        # Particles declare with form="qualified"/"unqualified",
+        # else the schema's elementFormDefault (elements) /
+        # attributeFormDefault (attributes) — both default
+        # unqualified.
+        def form_namespace(particle, index)
+          default = if particle.name == "element"
+                      index.element_default
+                    else
+                      index.attribute_default
+                    end
+          case particle["form"]
+          when "qualified" then index.target_namespace
+          when "unqualified" then ""
+          else default ? index.target_namespace : ""
+          end
+        end
+        def child_findings(child, model, index)
+          qname = qname(child)
+          findings = []
+          if model.declared_children.include?(qname)
+            declaration = index.elements[qname]
+            findings << nil_finding(child, declaration) if declaration
+          elsif undeclared_strict_wildcard_match?(child, model, index,
+                                                  qname)
+            findings << Moxml::XSD::ValidationError.new(
+              message: "element <#{local(qname)}> matches a strict " \
+                       "wildcard but is not declared",
+              path: path_of(child),
+            )
+          end
+          findings.concat(
+            attribute_findings(child, index.contents[qname], index),
+          )
+          findings
+        end
+        def undeclared_strict_wildcard_match?(_child, model, index, qname)
+          wildcard = model.any
+          return false unless wildcard&.strict?
+          return false if index.elements.key?(qname)
+          namespace = resolve_namespace(qname, index)
+          wildcard.covers?(namespace) && !index.elements.key?(qname)
+        end
+        def attribute_findings(element, model, index)
+          return [] unless model
+          any_attribute = model.any_attribute
+          element.attributes.filter_map do |attribute|
+            next if attribute.namespace&.uri == XSI_NS
+            qname = attribute_qname(attribute)
+            declared = model.declared_attributes.include?(qname) ||
+              index.attributes.key?(qname)
+            next if declared
+            next unless any_attribute&.strict?
+            next if index.attributes.key?(qname)
+            next unless any_attribute.covers?(
+              resolve_namespace(qname, index),
+            )
+            Moxml::XSD::ValidationError.new(
+              message: "attribute #{local(qname)} matches a strict " \
+                       "wildcard but is not declared",
+              path: path_of(element),
+            )
+          end
+        end
+        def nil_finding(element, declaration)
+          return if declaration[:nillable]
+          value = element.attributes.find do |attribute|
+            attribute.namespace&.uri == XSI_NS &&
+              attribute.name == "nil"
+          end&.value
+          return unless %w[true 1].include?(value)
+          Moxml::XSD::ValidationError.new(
+            message: "element <#{element.name}> is not nillable but " \
+                     "carries xsi:nil=\"#{value}\"",
+            path: path_of(element),
+          )
+        end
+        # {uri}local → the wildcard vocabulary: :tns when the
+        # namespace is the schema's target, :local when empty, the
+        # URI otherwise.
+        def resolve_namespace(qname, index)
+          namespace = namespace_of(qname)
+          if namespace.empty?
+            :local
+          elsif namespace == index.target_namespace
+            :tns
+          else
+            namespace
+          end
+        end
+        def qname(node)
+          "{#{node.namespace&.uri}}#{node.name}"
+        end
+        def attribute_qname(attribute)
+          "{#{attribute.namespace&.uri}}#{attribute.name}"
+        end
+        def namespace_of(qname)
+          qname[/^\{(.*)\}/, 1].to_s
+        end
+        def local(qname)
+          qname[/\}(.*)$/, 1].to_s
+        end
+        def child_elements(node)
+          node.children.select(&:element?)
+        end
+        def path_of(node)
+          segments = [node.name]
+          current = node
+          while (parent = current.parent)&.element?
+            segments.unshift(parent.name)
+            current = parent
+          end
+          segments.join("/")
+        end
+      end
+    end
+  end
+end

data/lib/moxml/xsd.rb CHANGED Viewed

@@ -28,6 +28,8 @@ module Moxml
   module XSD
     SUPPORTED_ADAPTERS = %i[leptris nokogiri].freeze
+    autoload :SchemaRules, "moxml/xsd/schema_rules"
     # One validation finding, harmonized across adapters (#362.2):
     # +message+ always present; +line+ / +column+ when the engine
     # reports them; +path+ (the element path) when the engine
@@ -89,9 +91,11 @@ module Moxml
               "schema released (deterministic drop); compile a new one"
       end
-      def initialize(handle, context)
+      def initialize(handle, context, schema_source = nil)
         @handle = handle
         @context = context
+        @rules_index =
+          schema_source && SchemaRules.index(schema_source, context)
         assert_adapter_matches_handle!
       end
@@ -143,7 +147,16 @@ module Moxml
                   parsed
                 end
               end
-        @context.config.adapter.xsd_validate(@handle, doc.native)
+        engine_errors = @context.config.adapter.xsd_validate(
+          @handle, doc.native
+        )
+        return engine_errors unless @rules_index
+        # The #452 post-validation rules only ever add findings for
+        # documents the engine accepted; exact duplicates are
+        # dropped for engines that already detect them.
+        (engine_errors +
+          SchemaRules.findings(doc, @rules_index)).uniq
       end
       def valid?(node_or_xml)

data/spec/moxml/xsd_underdetection_spec.rb ADDED Viewed

@@ -0,0 +1,174 @@
+# frozen_string_literal: true
+require "spec_helper"
+# #452: tier-1 engines can accept, inside their recognized scope,
+# instances that violate strict wildcards or xsi:nil. The
+# Ruby-side SchemaRules post-validation closes those gaps from the
+# schema source; findings merge with the engine's (duplicates
+# dropped), so every adapter answers invalid for the four
+# corpus shapes.
+RSpec.describe "Moxml::XSD tier-1 under-detections (#452)" do
+  %i[nokogiri leptris].each do |adapter_name|
+    describe "on #{adapter_name}" do
+      let(:ctx) { Moxml.new(adapter_name) }
+      before do
+        skip "#{adapter_name} requires an XSD-capable engine" unless
+          Moxml::XSD.supported?(ctx)
+      end
+      describe "strict xs:any with an undeclared element" do
+        let(:schema) do
+          ctx.xsd(<<~XSD)
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                targetNamespace="http://example.com/w"
+                elementFormDefault="qualified">
+              <xs:element name="container">
+                <xs:complexType>
+                  <xs:sequence>
+                    <xs:any namespace="##targetNamespace"
+                            processContents="strict" minOccurs="0"/>
+                  </xs:sequence>
+                </xs:complexType>
+              </xs:element>
+              <xs:element name="known" type="xs:string"/>
+            </xs:schema>
+          XSD
+        end
+        it "rejects the undeclared wildcard match" do
+          doc = ctx.parse(
+            '<container xmlns="http://example.com/w"><unknown>x</unknown></container>',
+          )
+          expect(schema.valid?(doc)).to be(false)
+          expect(schema.validate(doc).map(&:message)).to include(
+            /matches a strict wildcard but is not declared/,
+          )
+        end
+        it "accepts the declared wildcard match" do
+          doc = ctx.parse(
+            '<container xmlns="http://example.com/w"><known>x</known></container>',
+          )
+          expect(schema.valid?(doc)).to be(true)
+        end
+        it "leaves lax wildcards to the engine" do
+          lax = ctx.xsd(<<~XSD)
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                targetNamespace="http://example.com/w"
+                elementFormDefault="qualified">
+              <xs:element name="container">
+                <xs:complexType>
+                  <xs:sequence>
+                    <xs:any namespace="##targetNamespace"
+                            processContents="lax" minOccurs="0"/>
+                  </xs:sequence>
+                </xs:complexType>
+              </xs:element>
+            </xs:schema>
+          XSD
+          doc = ctx.parse(
+            '<container xmlns="http://example.com/w"><unknown>x</unknown></container>',
+          )
+          expect(lax.valid?(doc)).to be(true)
+        end
+      end
+      describe "strict xs:anyAttribute with an undeclared attribute" do
+        let(:schema) do
+          ctx.xsd(<<~XSD)
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                targetNamespace="http://example.com/aa"
+                elementFormDefault="qualified">
+              <xs:element name="settings">
+                <xs:complexType>
+                  <xs:complexContent>
+                    <xs:restriction base="xs:anyType">
+                      <xs:attribute name="lang"/>
+                      <xs:anyAttribute namespace="##targetNamespace ##local"
+                                       processContents="strict"/>
+                    </xs:restriction>
+                  </xs:complexContent>
+                </xs:complexType>
+              </xs:element>
+            </xs:schema>
+          XSD
+        end
+        it "rejects the undeclared wildcard match" do
+          doc = ctx.parse(
+            '<settings xmlns="http://example.com/aa" lang="en" bogus="1">v</settings>',
+          )
+          expect(schema.valid?(doc)).to be(false)
+          expect(schema.validate(doc).map(&:message)).to include(
+            /attribute bogus matches a strict wildcard but is not declared/,
+          )
+        end
+        it "accepts the declared attribute" do
+          # self-closing: the empty-content-type reading of the
+          # restriction is the engine's answer, not this rule's
+          doc = ctx.parse(
+            '<settings xmlns="http://example.com/aa" lang="en"/>',
+          )
+          expect(schema.valid?(doc)).to be(true)
+        end
+      end
+      describe "xsi:nil on a non-nillable element" do
+        let(:schema) do
+          ctx.xsd(<<~XSD)
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                elementFormDefault="qualified">
+              <xs:element name="memo" type="xs:string" nillable="true"/>
+              <xs:element name="strict" type="xs:string"/>
+            </xs:schema>
+          XSD
+        end
+        it "rejects xsi:nil on the non-nillable declaration" do
+          doc = ctx.parse(
+            '<strict xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true"/>',
+          )
+          expect(schema.valid?(doc)).to be(false)
+          expect(schema.validate(doc).map(&:message)).to include(
+            /is not nillable but carries xsi:nil/,
+          )
+        end
+        it "accepts xsi:nil on the nillable declaration" do
+          doc = ctx.parse(
+            '<memo xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:nil="true"/>',
+          )
+          expect(schema.valid?(doc)).to be(true)
+        end
+        it "accepts the element without xsi:nil" do
+          doc = ctx.parse("<strict>text</strict>")
+          expect(schema.valid?(doc)).to be(true)
+        end
+      end
+      describe "wrong-namespace root" do
+        let(:schema) do
+          ctx.xsd(<<~XSD)
+            <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
+                targetNamespace="http://example.com/q"
+                elementFormDefault="qualified">
+              <xs:element name="note" type="xs:string"/>
+            </xs:schema>
+          XSD
+        end
+        it "rejects the root in the wrong namespace" do
+          doc = ctx.parse(
+            '<note xmlns="http://example.com/other">hi</note>',
+          )
+          expect(schema.valid?(doc)).to be(false)
+        end
+      end
+    end
+  end
+end

metadata CHANGED Viewed

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.5.157
+  version: 0.5.159
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-23 00:00:00.000000000 Z
+date: 2026-10-24 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -318,6 +318,7 @@ files:
 - lib/moxml/xpath/ruby/generator.rb
 - lib/moxml/xpath/ruby/node.rb
 - lib/moxml/xsd.rb
+- lib/moxml/xsd/schema_rules.rb
 - lib/moxml/xslt.rb
 - lib/moxml/xslt/stylesheet.rb
 - moxml.gemspec
@@ -631,6 +632,7 @@ files:
 - spec/moxml/xsd_handle_mismatch_spec.rb
 - spec/moxml/xsd_release_spec.rb
 - spec/moxml/xsd_spec.rb
+- spec/moxml/xsd_underdetection_spec.rb
 - spec/moxml/xslt/stylesheet_spec.rb
 - spec/performance/README.md
 - spec/performance/benchmark_spec.rb