moxml 0.6.3 → 0.6.4

data/spec/moxml/xsd_composed_spec.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "fileutils"
+require "tmpdir"
+
+# moxml#522: composed-schema strict admission. The facade owns the
+# composition — it resolves the instance's xsi:schemaLocation hints
+# against the schema's own path, walks the schema graph
+# (include/import/redefine) for the unit closure, and dismisses
+# engine "not declared (strict)" rows the composed declaration index
+# refutes — global declarations AND attributeGroup members. The
+# engine admission gap itself is RESOLVED in leptris 1.9.409
+# (leptris#1964 — register entry D-23). The 1.9.409 namespace-aware
+# particle wave carries an upstream schG2 lexical regression
+# (leptris#1976, residual leptris#1979 — register entry D-24); its rows are lexical, not
+# admission rows, and pass through untouched here.
+RSpec.describe "Moxml::XSD::Schema composed-schema validation (#522)" do
+  let(:ctx) { Moxml.new(:leptris) }
+  let(:main_xsd) do
+    <<~XSD
+      <?xml version="1.0"?>
+      <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+        <xsd:attribute name="att1" type="xsd:string"/>
+        <xsd:element name="doc">
+          <xsd:complexType>
+            <xsd:attributeGroup ref="main"/>
+          </xsd:complexType>
+        </xsd:element>
+        <xsd:attributeGroup name="main">
+          <xsd:attribute ref="att1"/>
+          <xsd:anyAttribute namespace="##any"/>
+        </xsd:attributeGroup>
+      </xsd:schema>
+    XSD
+  end
+  # The auxiliary unit: a global declaration the head unit never saw.
+  let(:aux_xsd) do
+    <<~XSD
+      <?xml version="1.0"?>
+      <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                  targetNamespace="http://aux">
+        <xsd:attribute name="ext" type="xsd:string"/>
+      </xsd:schema>
+    XSD
+  end
+
+  # Per-example fixture tempdir: created by the let, removed in the
+  # after hook. Plain lets + methods keep the suite ivar-free
+  # (house law).
+  let(:dir) { Dir.mktmpdir("moxml522") }
+
+  after { FileUtils.remove_entry(dir) }
+
+  def unit(name)
+    File.join(dir, name)
+  end
+
+  before do
+    File.write(unit("main.xsd"), main_xsd)
+    File.write(unit("aux.xsd"), aux_xsd)
+  end
+
+  it "unions the instance's hint documents into the validation" do
+    schema = ctx.xsd_file(unit("main.xsd"))
+    doc = ctx.parse(
+      '<doc xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' \
+      'xmlns:e="http://aux" xsi:noNamespaceSchemaLocation="main.xsd" ' \
+      'xsi:schemaLocation="http://aux aux.xsd" att1="x" e:ext="y"/>',
+    )
+    expect(schema.validate(doc)).to be_empty
+  end
+
+  it "dismisses the engine's not-declared rows the union refutes" do
+    # Without the union the engine reports the aux attribute as
+    # undeclared; with it, the composed declaration index refutes
+    # the row. The engine may carry either the attribute-level row
+    # or the element-level root row (mixed-tns mis-admission) —
+    # both are refutable.
+    schema = ctx.xsd_file(unit("main.xsd"))
+    doc = ctx.parse(
+      '<doc xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' \
+      'xmlns:e="http://aux" xsi:noNamespaceSchemaLocation="main.xsd" ' \
+      'xsi:schemaLocation="http://aux aux.xsd" att1="x" e:ext="y">text</doc>',
+    )
+    errors = schema.validate(doc)
+    expect(errors.map(&:message)).not_to include(
+      /not declared \(strict\)/,
+    )
+  end
+
+  it "keeps genuinely undeclared attribute rows" do
+    schema = ctx.xsd_file(unit("main.xsd"))
+    doc = ctx.parse(
+      '<doc xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' \
+      'xsi:noNamespaceSchemaLocation="main.xsd" att1="x" ghost="z"/>',
+    )
+    # `ghost` is declared nowhere: the strict row (when the engine
+    # emits one) must survive the dismissal.
+    errors = schema.validate(doc).map(&:message)
+    expect(errors.grep_v(/ghost.*not declared/)).to be_empty
+  end
+
+  it "does not build a union for string-compiled schemas" do
+    schema = ctx.xsd(main_xsd)
+    doc = ctx.parse("<doc att1=\"x\"/>")
+    expect(schema.validate(doc)).to be_empty
+  end
+
+  # The attgC class (moxml#522): the attribute is a member of an
+  # attributeGroup reached through xs:redefine (the body hooks the
+  # original with a self-ref — 4.2.2) and an import. The instance
+  # carries no xsi hints; the composed unit closure must see the
+  # redefined/imported documents through the schema graph alone.
+  describe "group-member admission through the schema graph" do
+    let(:group_xsd) do
+      <<~XSD
+        <?xml version="1.0"?>
+        <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                    xmlns:imp="http://imported">
+          <xsd:import namespace="http://imported" schemaLocation="group.imp"/>
+          <xsd:redefine schemaLocation="group.red">
+            <xsd:attributeGroup name="car">
+              <xsd:attributeGroup ref="car"/>
+              <xsd:attributeGroup ref="imp:bar"/>
+            </xsd:attributeGroup>
+          </xsd:redefine>
+          <xsd:element name="doc" type="test"/>
+          <xsd:complexType name="test">
+            <xsd:attributeGroup ref="car"/>
+          </xsd:complexType>
+        </xsd:schema>
+      XSD
+    end
+    let(:group_red_xsd) do
+      <<~XSD
+        <?xml version="1.0"?>
+        <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
+          <xsd:attributeGroup name="car">
+            <xsd:attribute name="att1" type="xsd:int"/>
+          </xsd:attributeGroup>
+        </xsd:schema>
+      XSD
+    end
+    let(:group_imp_xsd) do
+      <<~XSD
+        <?xml version="1.0"?>
+        <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+                    targetNamespace="http://imported">
+          <xsd:attributeGroup name="bar">
+            <xsd:attribute name="att4" type="xsd:int"/>
+          </xsd:attributeGroup>
+        </xsd:schema>
+      XSD
+    end
+
+    before do
+      File.write(unit("group.xsd"), group_xsd)
+      File.write(unit("group.red"), group_red_xsd)
+      File.write(unit("group.imp"), group_imp_xsd)
+    end
+
+    it "admits redefined and imported group members on the element" do
+      schema = ctx.xsd_file(unit("group.xsd"))
+      doc = ctx.parse(
+        '<doc xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' \
+        'xmlns:imp="http://imported" ' \
+        'xsi:noNamespaceSchemaLocation="group.xsd" att1="1" imp:att4="2"/>',
+      )
+      expect(schema.validate(doc)).to be_empty
+    end
+
+    it "keeps rows for attributes no unit of the composition declares" do
+      schema = ctx.xsd_file(unit("group.xsd"))
+      doc = ctx.parse(
+        '<doc xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" ' \
+        'xsi:noNamespaceSchemaLocation="group.xsd" att1="1" ghost="z"/>',
+      )
+      errors = schema.validate(doc).map(&:message)
+      expect(errors.grep_v(/ghost.*not declared/)).to be_empty
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: moxml
 version: !ruby/object:Gem::Version
-  version: 0.6.3
+  version: 0.6.4
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-11-05 00:00:00.000000000 Z
+date: 2026-11-06 00:00:00.000000000 Z
 dependencies: []
 description: |
   Moxml is a unified XML manipulation library that provides a common API
@@ -478,7 +478,7 @@ files:
 - spec/moxml/adapter/leptris_attribute_packet_spec.rb
 - spec/moxml/adapter/leptris_attribute_snapshot_spec.rb
 - spec/moxml/adapter/leptris_binding_cap_spec.rb
-- spec/moxml/adapter/leptris_children_columnar_spec.rb
+- spec/moxml/adapter/leptris_children_address_spec.rb
 - spec/moxml/adapter/leptris_composed_schema_spec.rb
 - spec/moxml/adapter/leptris_contract_reads_spec.rb
 - spec/moxml/adapter/leptris_crossdoc_replace_spec.rb
@@ -626,6 +626,7 @@ files:
 - spec/moxml/xpath_capabilities_spec.rb
 - spec/moxml/xpath_spec.rb
 - spec/moxml/xsd_builtin_lexical_spec.rb
+- spec/moxml/xsd_composed_spec.rb
 - spec/moxml/xsd_conformance_cases_spec.rb
 - spec/moxml/xsd_engine_meta_spec.rb
 - spec/moxml/xsd_error_contract_spec.rb

data/spec/moxml/adapter/leptris_children_columnar_spec.rb

@@ -1,146 +0,0 @@
-# frozen_string_literal: true
-
-begin
-  require "leptris"
-rescue LoadError
-  # Leptris gem not available - skip all specs in this file
-  return
-end
-return unless Leptris::XML::Document.respond_to?(:create)
-# The columnar children lane rides the binding's walk_columnar face
-# (leptris-ruby#527/#532); older bindings keep the per-node children
-# crossing, so the routing cannot be pinned there.
-return unless defined?(Leptris::XML::Native) &&
-  Leptris::XML::Native.respond_to?(:walk_columnar)
-
-require "moxml/adapter/leptris"
-
-RSpec.describe "Moxml::Adapter::Leptris columnar children (SOTA B2 walk row)" do
-  around do |example|
-    Moxml.with_config(:leptris, true, "UTF-8") do
-      example.run
-    end
-  end
-
-  let(:xml) do
-    <<~XML
-      <?xml version="1.0"?><r><a x="1">t</a><b/><c><d/></c><tail>z</tail></r>
-    XML
-  end
-
-  let(:doc) { Moxml.parse(xml) }
-  let(:root) { doc.root }
-  let(:root_native) { root.native }
-
-  # Counts real Native.walk_columnar C crossings inside the block —
-  # no stubs, the actual boundary traffic the walk row pays.
-  def with_crossing_count
-    calls = 0
-    tp = TracePoint.new(:c_call) do |t|
-      calls += 1 if t.method_id == :walk_columnar
-    end
-    result = nil
-    tp.enable { result = yield }
-    [calls, result]
-  end
-
-  describe "the columnar gate" do
-    it "face-probes walk_columnar on the binding" do
-      expect(Moxml::Adapter::Leptris::COLUMNAR_WALK).to be(true)
-      expect(Leptris::XML::Native.respond_to?(:walk_columnar)).to be(true)
-    end
-  end
-
-  describe "plain children reads" do
-    it "answer natives identical to the native children face" do
-      got = Moxml::Adapter::Leptris.children(root_native)
-      expected = Leptris::XML::NativeNode
-        .instance_method(:children).bind_call(root_native).to_a
-      expect(got.size).to eq(expected.size)
-      expect(got.map { |n| Moxml::Adapter::Leptris.node_name(n) })
-        .to eq(expected.map(&:name))
-      got.each_with_index do |native, i|
-        # native-cache identity: cached handles ARE the children_read
-        # wrappers, so the NodeSet contract holds.
-        expect(native).to equal(expected[i])
-      end
-    end
-
-    # Parsed-document wrappers mint with Identity::ChildReads above
-    # Moxml::Node, so consumer iteration on those wrappers dispatches
-    # to the binding's C read layer. The children FACE is pinned by
-    # driving it for every node of the cold subtree: one walk_columnar
-    # crossing primes the whole map, every deeper face read hits it.
-    it "pay ONE columnar crossing for a whole cold subtree" do
-      calls, = with_crossing_count do
-        walk_face = lambda do |native|
-          Moxml::Adapter::Leptris.children(native).each do |child|
-            walk_face.call(child)
-          end
-        end
-        walk_face.call(root_native)
-      end
-      expect(calls).to eq(1)
-    end
-
-    it "serve repeat face reads from the primed map without a crossing" do
-      calls, first = with_crossing_count do
-        Moxml::Adapter::Leptris.children(root_native)
-      end
-      expect(calls).to eq(1)
-      first_names = first.map { |n| Moxml::Adapter::Leptris.node_name(n) }
-      calls2, second = with_crossing_count do
-        Moxml::Adapter::Leptris.children(root_native)
-      end
-      expect(calls2).to eq(0)
-      expect(second.map { |n| Moxml::Adapter::Leptris.node_name(n) })
-        .to eq(first_names)
-    end
-  end
-
-  describe "mutation invalidation" do
-    # Read back through the adapter face: the map must never serve a
-    # list a mutation has invalidated.
-    def face_children_names
-      Moxml::Adapter::Leptris.children(root_native)
-        .map { |n| Moxml::Adapter::Leptris.node_name(n) }
-    end
-
-    it "sees children added after the map was primed" do
-      face_children_names # prime the map
-      root.add_child(doc.create_element("late"))
-      expect(face_children_names).to include("late")
-    end
-
-    it "sees children removed after the map was primed" do
-      face_children_names # prime the map
-      root.children.to_a.first.remove
-      expect(face_children_names).not_to include("a")
-    end
-
-    it "sees sibling insertions after the map was primed" do
-      face_children_names # prime the map
-      anchor = root.children.to_a.first
-      anchor.add_previous_sibling(doc.create_element("before2"))
-      expect(face_children_names).to include("before2")
-    end
-
-    it "sees replace after the map was primed" do
-      face_children_names # prime the map
-      victim = root.children.to_a.find { |n| n.name == "b" }
-      victim.replace(doc.create_element("swapped"))
-      expect(face_children_names).to include("swapped")
-      expect(face_children_names).not_to include("b")
-    end
-
-    it "sees content rewrites after the map was primed" do
-      face_children_names # prime the map
-      target = root.children.to_a.find { |n| n.name == "a" }
-      target.content = "rewritten"
-      names = face_children_names
-      expect(names).to include("a")
-      expect(root.children.to_a.find { |n| n.name == "a" }.text)
-        .to eq("rewritten")
-    end
-  end
-end