moxml 0.5.119 → 0.5.121

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7a30730e871854c7b88fc3b6a3498b4f4d5504ac47caa2aabcc530f2bf0eec96
-  data.tar.gz: 8d4f301d7d100cab15cc55b4f0e3db36bc5e50916775adfd34f64b816546d466
+  metadata.gz: 3e70385e5a2ffc34bc69d65011c6fead0dfdb3311ac44d68893990b714aa750b
+  data.tar.gz: 1d7d88feac80fdef1a56a5e09d333ee350bd9e2cc19c42a26e57a5283e8ab8ef
 SHA512:
-  metadata.gz: 4b61a839f7399e0b9e9236b1d921cfc161714b114d73da1b737a80c98795d8c88b96f8e85e71c3a71f58a090578b2ba6ffa4ec57cb9a6309cb53296bb000b277
-  data.tar.gz: b42fa624031b28da813039d441024be7766f8322fc54f247075b0c205cb79ec57052ababc789ab90f1c3b91b04a0ced4de85760af3178c1675aedd390fdd8046
+  metadata.gz: 846a93feb34b6de7dab678e91b72cfe8691b17fab1987605906919225ce406204b4beb2dbae3d8e95b54bdf42f1ec9895598c22e49d3816d866241f5cb6e0fad
+  data.tar.gz: 915721b24c27eef6790fa31f22f82dd1f6b3d2998b9c5824c4515a50f4d0500ff2bd40874b414f8a02dce433d90455eda067dd07f35ad127df46182dac8133a1

data/benchmarks/generate_report.rb

@@ -143,10 +143,10 @@ class MoxmlBenchmarkReport
   end
 
   def benchmark_parse(context, xml)
-    result = nil
+    nil
     Benchmark.ips do |x|
       x.config(time: 2, warmup: 1)
-      x.report("parse") { result = context.parse(xml) }
+      x.report("parse") { context.parse(xml) }
     end.entries.first.ips.round(2)
   rescue StandardError => e
     @errors[context.config.adapter_name] << "Parse error: #{e.message}"

data/lib/moxml/adapter/base.rb

@@ -272,6 +272,30 @@ module Moxml
                 "XSD validation requires an adapter with an XSD engine"
         end
 
+        def xsd_compile_file(_path)
+          raise Moxml::NotImplementedError,
+                "XSD validation requires an adapter with an XSD engine"
+        end
+
+        def xsd_builtin_valid?(_builtin, _lexical)
+          raise Moxml::NotImplementedError,
+                "XSD validation requires an adapter with an XSD engine"
+        end
+
+        def xsd_declarations(_xsd_handle); end
+
+        def xsd_compile_error(_xsd_handle); end
+
+        def xsd_simple_valid?(_xsd_handle, _type_name, _lexical)
+          raise Moxml::NotImplementedError,
+                "XSD validation requires an adapter with an XSD engine"
+        end
+
+        def xsd_content_valid?(_xsd_handle, _element_name, _children)
+          raise Moxml::NotImplementedError,
+                "XSD validation requires an adapter with an XSD engine"
+        end
+
         # Apply a compiled stylesheet; returns the engine's result
         # document, or nil when the output method cannot produce one
         # (text). @params is the flat quoted name/value list.

data/lib/moxml/adapter/leptris.rb

@@ -239,6 +239,44 @@ module Moxml
           ::Leptris::XML::XSD.compile(schema_source)
         end
 
+        def xsd_compile_file(path)
+          unless XSD_SUPPORTED && ::Leptris::XML::XSD.respond_to?(:compile_file)
+            raise Moxml::NotImplementedError,
+                  "XSD validation requires the leptris 1.9.326+ engine"
+          end
+
+          ::Leptris::XML::XSD.compile_file(path)
+        end
+
+        def xsd_builtin_valid?(builtin, lexical)
+          unless XSD_SUPPORTED
+            raise Moxml::NotImplementedError,
+                  "XSD validation requires an adapter with an XSD engine"
+          end
+
+          ::Leptris::XML::XSD.builtin_valid?(builtin, lexical)
+        end
+
+        def xsd_declarations(xsd_handle)
+          xsd_handle.declaration_count
+        end
+
+        def xsd_compile_error(xsd_handle)
+          xsd_handle.error
+        end
+
+        def xsd_simple_valid?(xsd_handle, type_name, lexical)
+          xsd_handle.simple_valid?(type_name, lexical)
+        end
+
+        def xsd_content_valid?(xsd_handle, element_name, children)
+          # The binding reads each child's name + effective
+          # namespace through its own node API — pass the natives.
+          xsd_handle.content_valid?(
+            element_name, children.map(&:native)
+          )
+        end
+
         def xsd_validate(xsd_handle, native_document)
           # +xsd_handle+ is the binding's Leptris::XML::XSD::Schema;
           # validate_errors takes the binding document and returns
@@ -2220,11 +2258,22 @@ module Moxml
               # absorbed-source nodes upstream.
               child_doc = NN_DOCUMENT.bind_call(child)
               parent_doc = NN_DOCUMENT.bind_call(parent)
-              if child_doc && parent_doc &&
-                  !child_doc.equal?(parent_doc) && child.node_type == :element
-                absorb_source_document(to_binding(parent_doc), to_binding(child_doc))
-                return structural_adopt(parent, child) unless
-                  source_absorbed_into?(parent, child)
+              if child_doc && parent_doc && !child_doc.equal?(parent_doc)
+                if child.node_type == :element
+                  absorb_source_document(to_binding(parent_doc), to_binding(child_doc))
+                  return structural_adopt(parent, child) unless
+                    source_absorbed_into?(parent, child)
+                else
+                  # moxml#347: the C add_child's foreign-child
+                  # fallback dispatches parent.add_child through
+                  # RUBY — on Identity natives the contract modules
+                  # shadow the C method, so that dispatch re-enters
+                  # Moxml's add_child forever. Foreign content kinds
+                  # (text/comment/CDATA/PI) rebuild in the parent's
+                  # pool directly; they carry no cross-document
+                  # identity worth a move.
+                  return rebuild_foreign_child(parent, child)
+                end
               end
 
               doc = NN_DOCUMENT.bind_call(parent)

data/lib/moxml/context.rb

@@ -156,6 +156,14 @@ module Moxml
       Moxml::XSD::Schema.new(handle, self)
     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).
+    def xsd_file(path)
+      handle = config.adapter.xsd_compile_file(path.to_s)
+      Moxml::XSD::Schema.new(handle, self)
+    end
+
     def xslt(stylesheet)
       source = case stylesheet
                when Moxml::Document then stylesheet.to_xml

data/lib/moxml/version.rb

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

data/lib/moxml/xsd.rb

@@ -38,6 +38,14 @@ module Moxml
         adapter.const_defined?(:XSD_SUPPORTED) &&
           adapter.const_get(:XSD_SUPPORTED)
       end
+
+      # Lexical validation against the built-in type table (the
+      # "xs:NAME" reference spelling). Raises ArgumentError when the
+      # name is not in the table; NotImplementedError on adapters
+      # without an engine.
+      def builtin_valid?(context, builtin, lexical)
+        context.config.adapter.xsd_builtin_valid?(builtin, lexical)
+      end
     end
 
     # A compiled schema (adapter-owned handle). Validation results
@@ -61,6 +69,35 @@ module Moxml
       def valid?(node_or_xml)
         validate(node_or_xml).empty?
       end
+
+      # Number of top-level schema declarations the compiler
+      # recognized.
+      def declarations
+        @context.config.adapter.xsd_declarations(@handle)
+      end
+
+      # The engine's schema-level compile error, or nil when the
+      # schema compiled cleanly.
+      def compile_error
+        @context.config.adapter.xsd_compile_error(@handle)
+      end
+
+      # Lexical validation of +lexical+ against the schema's user
+      # simpleType +type_name+. Unknown type names raise.
+      def simple_valid?(type_name, lexical)
+        @context.config.adapter.xsd_simple_valid?(
+          @handle, type_name, lexical
+        )
+      end
+
+      # Content-model check for one element's children. +children+
+      # are Moxml nodes (names + effective namespaces are read
+      # engine-side). Unknown element names raise.
+      def content_valid?(element_name, children)
+        @context.config.adapter.xsd_content_valid?(
+          @handle, element_name, children
+        )
+      end
     end
   end
 end

data/spec/moxml/adapter/leptris_adoption_spec.rb

@@ -146,4 +146,46 @@ RSpec.describe "leptris cross-document adoption" do
       expect(doc.at("//r/e").text).to eq("t")
     end
   end
+
+  # moxml#347: the C add_child's foreign-child fallback dispatches
+  # parent.add_child through Ruby — on Identity natives the contract
+  # modules shadow the C method and the dispatch re-enters Moxml's
+  # add_child (SystemStackError). Foreign content kinds rebuild in
+  # the parent's pool; foreign elements absorb/move.
+  context "when adding foreign children (moxml#347)" do
+    let(:fragment_xml) do
+      "<__root__>hello<b attr=\"1\"/>world<!-- note --><?tgt data?><![CDATA[x < y]]></__root__>"
+    end
+
+    it "appends every node kind from a same-context fragment" do
+      doc = ctx.parse("<bibitem/>")
+      frag = ctx.parse(fragment_xml)
+      frag.root.children.each { |c| doc.root.add_child(c) }
+      expect(doc.root.to_xml).to include("<b attr=\"1\">")
+      expect(doc.root.text).to include("hello")
+      expect(doc.root.to_xml).to include("<!-- note -->")
+      expect(doc.root.to_xml).to include("<?tgt data?>")
+      expect(doc.root.to_xml).to include("<![CDATA[x < y]]>")
+    end
+
+    it "appends every node kind across contexts without recursing" do
+      doc = ctx.parse("<bibitem/>")
+      frag = Moxml.new(:leptris).parse(fragment_xml)
+      frag.root.children.each { |c| doc.root.add_child(c) }
+      expect(doc.root.to_xml).to include("<b attr=\"1\">")
+      expect(doc.root.to_xml).to include("<!-- note -->")
+      expect(doc.root.to_xml).to include("<?tgt data?>")
+      expect(doc.root.to_xml).to include("<![CDATA[x < y]]>")
+    end
+
+    it "moves foreign elements by reference (the absorb path stays first)" do
+      doc = ctx.parse("<r><a/></r>")
+      other = Moxml.new(:leptris).parse("<other><new/></other>")
+      child = other.root.children.first
+      doc.root.add_child(child)
+      expect(doc.root.children.last).to eq(child)
+      expect(child["probe"] = "1").to eq("1")
+      expect(doc.at("//r/new")["probe"]).to eq("1")
+    end
+  end
 end

data/spec/moxml/xsd_spec.rb

@@ -14,9 +14,12 @@ RSpec.describe Moxml::XSD do
         <xs:element name="note" type="t_note"/>
         <xs:complexType name="t_note">
           <xs:sequence>
-            <xs:element name="to" type="xs:string"/>
+            <xs:element name="to" type="t_string"/>
           </xs:sequence>
         </xs:complexType>
+        <xs:simpleType name="t_string">
+          <xs:restriction base="xs:string"/>
+        </xs:simpleType>
       </xs:schema>
     XSD
   end
@@ -55,6 +58,49 @@ RSpec.describe Moxml::XSD do
       expect(schema.valid?("<note><wrong/></note>")).to be(false)
     end
 
+    it "surfaces the lexical, census, and content faces" do
+      schema = ctx.xsd(schema_text)
+      expect(schema.declarations).to be >= 2
+      expect(schema.compile_error).to be_nil
+      expect(schema.simple_valid?("t_string", "abc")).to be(true)
+    end
+
+    it "checks built-in lexical forms" do
+      expect(described_class.builtin_valid?(ctx, "xs:integer", "3")).to be(true)
+      expect(described_class.builtin_valid?(ctx, "xs:integer", "x")).to be(false)
+      expect do
+        described_class.builtin_valid?(ctx, "xs:nope", "3")
+      end.to raise_error(ArgumentError)
+    end
+
+    it "checks content models through moxml nodes" do
+      schema = ctx.xsd(schema_text)
+      doc = ctx.parse("<note><to>You</to></note>")
+      expect(schema.content_valid?("note", [doc.at("//to")])).to be(true)
+      expect(schema.content_valid?("note", [])).to be(false)
+    end
+
+    it "compiles from a file with relative includes" do
+      require "tmpdir"
+      Dir.mktmpdir do |dir|
+        File.write(File.join(dir, "main.xsd"), <<~XSD)
+          <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+            <xs:include schemaLocation="inc.xsd"/>
+          </xs:schema>
+        XSD
+        File.write(File.join(dir, "inc.xsd"), <<~XSD)
+          <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+            <xs:element name="note" type="xs:string"/>
+          </xs:schema>
+        XSD
+        schema = ctx.xsd_file(File.join(dir, "main.xsd"))
+        # The include pulled the declaration in (both files' schema
+        # elements census).
+        expect(schema.declarations).to be >= 1
+        expect(schema.valid?("<note>x</note>")).to be(true)
+      end
+    end
+
     it "derives XSD_SUPPORTED from the engine face gate" do
       # The capability flag must not outrun the engine faces: a
       # misreleased lockstep (NATIVE_PLAN_STRUCTS lesson) would arm

data/spec/performance/benchmark_spec.rb

@@ -46,10 +46,10 @@ RSpec.shared_examples "Performance Examples" do
       end
 
       it "meets Parser performance threshold", :performance do
-        result = nil
+        nil
         report = Benchmark.ips do |x|
           x.config(time: 5, warmup: 2)
-          x.report("Parser") { result = context.parse(large_xml) }
+          x.report("Parser") { context.parse(large_xml) }
         end
 
         threshold = thresholds.dig(context.config.adapter_name, :parser) || 1

metadata

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