lutaml-model 0.8.145 → 0.8.147

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1d4a991baea8734712513f2d1ffb0025d0a5867f174a40b32bee58b1be5017c5
-  data.tar.gz: f1713d5b0ef5024da66ee23f8251604da86fd3f8d7035e7f64118bf080ea9128
+  metadata.gz: 73297b741e0c6f033811660bef32b0bcd51529d9ebd517ec3c67cd386e7134e6
+  data.tar.gz: a8fd9b7f9f0d6d95fd40441a116dc8e81639b8ef8e79c5c9c026c7d82691a7bf
 SHA512:
-  metadata.gz: db827973c88ea9fe1779a0105d18ef1d0f93868fa4a59147a029c504005ec5f5e50378a7f90c490097e24d20c62fb33531a8fe277fb7620ed3cd17debdd2adaf
-  data.tar.gz: 90045bda2ce6c2605ca3708527c44ad7811cacb6cb8d4f72d83f3a875a3a043a84503dc48f24f716d94f5e92e367d6a4bfb2fa556982d14db65125623d885252
+  metadata.gz: 24717f565b570a808908949176ba5b006fc1b176018776a85f62df04d63e152bb8fc6e5c88badca9d7ede0911cffe79b65c908de9fec356af56f4fc7ba0a7b2e
+  data.tar.gz: a3203db4195bf6f4a5d32529febd708ab574c07e0d7b93dfdb64674d1e0bdd37c5a2d5965e8506d023ea90c70d620622c38d43b3a02072f1fc4c014483b65590

data/lib/lutaml/key_value/adapter/yamls/standard_adapter.rb

@@ -17,7 +17,7 @@ module Lutaml
 
               begin
                 results << YAML.safe_load(yaml, aliases: true)
-              rescue Psych::SyntaxError => e
+              rescue *Lutaml::Model::Utils.yaml_parse_errors => e
                 warn "Skipping invalid yaml: #{e.message}"
               end
             end

data/lib/lutaml/model/utils.rb

@@ -34,6 +34,17 @@ module Lutaml
           false
         end
 
+        # Parse-error classes of every YAML engine that may be answering
+        # ::YAML in this process. A host bundle can rebind ::YAML (a
+        # Psych drop-in), so the multi-document skip-rescues must cover
+        # each loaded engine's parse error, not only Psych's (#1053: a
+        # raw Yeptris::ParseError escaped from_yamls).
+        def yaml_parse_errors
+          errors = [Psych::SyntaxError]
+          errors << Yeptris::ParseError if defined?(Yeptris::ParseError)
+          errors
+        end
+
         # Convert string to camel case (cached)
         def camel_case(str)
           return "" if str.nil? || str.empty?

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.145"
+    VERSION = "0.8.147"
   end
 end

data/lib/lutaml/xml/leptris/plan_hydrator.rb

@@ -94,6 +94,50 @@ module Lutaml
             instance
           end
 
+          # leptris#1874: snapshot rows -> the ns_data hash
+          # ({path => {prefix_key => {uri:, prefix:, format:}}}), the
+          # exact shape the recursion builds. Public: it is the
+          # contract the binding's snapshot rows must satisfy.
+          def ns_data_from_snapshot_rows(rows)
+            rows.each_with_object({}) do |row, result|
+              prefix = row[:prefix]
+              # One element carrying several declarations emits one
+              # row PER declaration with the same path — merge them,
+              # exactly as the recursion accumulates per path.
+              (result[row[:path]] ||= {})[row[:prefix] || :default] = {
+                uri: row[:href], prefix: prefix,
+                format: prefix ? :prefix : :default
+              }
+            end
+          end
+
+          def collect_native_namespaces(element, path = [], result = {})
+            if element.respond_to?(:namespace_declarations_snapshot)
+              return ns_data_from_snapshot_rows(
+                element.namespace_declarations_snapshot,
+              )
+            end
+
+            own = element.namespace_definitions
+            unless own.empty?
+              namespaces = {}
+              own.each do |ns|
+                key = ns.prefix || :default
+                namespaces[key] = { uri: ns.href, prefix: ns.prefix,
+                                    format: ns.prefix ? :prefix : :default }
+              end
+              result[path.dup] = namespaces
+            end
+            element.children.each do |child|
+              next unless child.is_a?(::Leptris::XML::Element)
+
+              path.push(child.name)
+              collect_native_namespaces(child, path, result)
+              path.pop
+            end
+            result
+          end
+
           private
 
           def record_declaration_plan(instance, node, model_class)
@@ -123,27 +167,15 @@ module Lutaml
           # Iterates children with an inline element filter:
           # element_children materializes a filtered array per node,
           # which the niso allocation gate caught at scale.
-          def collect_native_namespaces(element, path = [], result = {})
-            own = element.namespace_definitions
-            unless own.empty?
-              namespaces = {}
-              own.each do |ns|
-                key = ns.prefix || :default
-                namespaces[key] = { uri: ns.href, prefix: ns.prefix,
-                                    format: ns.prefix ? :prefix : :default }
-              end
-              result[path.dup] = namespaces
-            end
-            element.children.each do |child|
-              next unless child.is_a?(::Leptris::XML::Element)
-
-              path.push(child.name)
-              collect_native_namespaces(child, path, result)
-              path.pop
-            end
-            result
-          end
-
+          #
+          # leptris#1874: when the binding exposes the bulk snapshot
+          # face (namespace_declarations_snapshot — one FFI crossing
+          # for the whole subtree; shipped engine-side in 1.9.387),
+          # the whole-subtree Ruby recursion collapses into a single
+          # call. Rows: {path: [names...], prefix: String|nil,
+          # href: String} in pre-order, paths relative to the
+          # receiver. The face probe keeps older bindings on the
+          # recursion unchanged.
           def register
             Lutaml::Model::Config.default_register
           end

data/lib/lutaml/xml/schema/xsd/schema.rb

@@ -86,7 +86,9 @@ module Lutaml
                 "import",
                 model,
                 schema,
-                namespace: schema.attributes["namespace"].value,
+                # An xs:import without a namespace attribute is legal
+                # (XSD 1.0 §3.13.2); the raw read stays nil-safe (#1051).
+                namespace: schema.attributes["namespace"]&.value,
               )
             end
           end

data/lib/lutaml/yamls/adapter/standard_adapter.rb

@@ -22,7 +22,7 @@ module Lutaml
           end
 
           results
-        rescue Psych::SyntaxError => e
+        rescue *Lutaml::Model::Utils.yaml_parse_errors => e
           warn "Skipping invalid yaml: #{e.message}"
           parse_with_split(yamls)
         end
@@ -36,7 +36,7 @@ module Lutaml
             begin
               doc = YAML.safe_load(yaml, aliases: true)
               results << doc unless doc.nil?
-            rescue Psych::SyntaxError => e
+            rescue *Lutaml::Model::Utils.yaml_parse_errors => e
               warn "Skipping invalid yaml: #{e.message}"
             end
           end

data/spec/lutaml/model/yamls_spec.rb

@@ -154,6 +154,38 @@ RSpec.describe "Yamls" do
     end.to output(/Skipping invalid yaml: /).to_stderr
   end
 
+  # #1053: a host bundle can rebind ::YAML to another engine (a Psych
+  # drop-in), so the multi-doc lane must treat every loaded engine's
+  # parse error as a skippable document error — never let a raw engine
+  # error escape.
+  describe "engine parse errors" do
+    it "rescues every loaded YAML engine's parse errors" do
+      errors = Lutaml::Model::Utils.yaml_parse_errors
+
+      expect(errors).to include(Psych::SyntaxError)
+      if defined?(Yeptris::ParseError)
+        expect(errors).to include(Yeptris::ParseError)
+      end
+    end
+
+    it "skips an invalid document when the active engine raises its own parse error" do
+      skip "yeptris not loadable in this process" unless Lutaml::Model::Utils.safe_load("yeptris", :Yeptris)
+
+      allow(YAML).to receive(:load_stream).and_raise(
+        Yeptris::ParseError.new("parse failed: unexpected parser state at line 11, column 26"),
+      )
+
+      expect do
+        expect(Lutaml::Yamls::Adapter::StandardAdapter.parse(invalid_yamls_content)).to eq(
+          [
+            { "full_name" => "John", "age" => 30, "address" => { "city" => "New York" } },
+            { "full_name" => "Bob", "age" => 35, "address" => { "city" => "Paris" } },
+          ],
+        )
+      end.to output(/Skipping invalid yaml: /).to_stderr
+    end
+  end
+
   describe "parsing" do
     it "handles empty documents" do
       yamls_with_empty_docs = <<~YAMLS

data/spec/lutaml/xml/leptris/plan_hydrator_ns_snapshot_spec.rb

@@ -0,0 +1,61 @@
+require "spec_helper"
+require_relative "../../../../lib/lutaml/model"
+
+# leptris#1874: the plan hydrator's namespace collection collapses the
+# whole-subtree Ruby recursion (one namespace_definitions FFI crossing
+# per node) into the engine's bulk snapshot face when the binding
+# exposes it. These specs pin the ROW CONTRACT the binding must
+# satisfy and the dispatch, so the binding PR can be verified without
+# waiting for the native pin bump.
+# A real lightweight struct standing in for the future binding
+# element: responds to the bulk face with fixed rows, carries no
+# behavior of its own.
+SnapshotFaceElement = Struct.new(:rows) do
+  def namespace_declarations_snapshot
+    rows
+  end
+end
+
+RSpec.describe Lutaml::Xml::Leptris::PlanHydrator do
+  describe ".ns_data_from_snapshot_rows" do
+    it "builds the ns_data hash from pre-order snapshot rows" do
+      rows = [
+        { path: [], prefix: nil, href: "urn:d" },
+        { path: [], prefix: "a", href: "urn:a" },
+        { path: ["c1"], prefix: "b", href: "urn:b" },
+        { path: ["c2"], prefix: nil, href: "urn:d2" },
+      ]
+
+      result = described_class.ns_data_from_snapshot_rows(rows)
+
+      expect(result).to eq(
+        [] => { default: { uri: "urn:d", prefix: nil,
+                           format: :default },
+                "a" => { uri: "urn:a", prefix: "a", format: :prefix } },
+        ["c1"] => { "b" => { uri: "urn:b", prefix: "b",
+                             format: :prefix } },
+        ["c2"] => { default: { uri: "urn:d2", prefix: nil,
+                               format: :default } },
+      )
+    end
+
+    it "returns an empty hash for a declaration-free subtree" do
+      expect(described_class.ns_data_from_snapshot_rows([])).to eq({})
+    end
+  end
+
+  describe "the snapshot face probe in collect_native_namespaces" do
+    it "prefers the bulk face when the binding exposes it" do
+      element = SnapshotFaceElement.new(
+        [{ path: ["x"], prefix: "p", href: "urn:p" }],
+      )
+
+      result = described_class.collect_native_namespaces(element)
+
+      expect(result).to eq(
+        ["x"] => { "p" => { uri: "urn:p", prefix: "p",
+                            format: :prefix } },
+      )
+    end
+  end
+end

data/spec/lutaml/xml/schema/xsd/import_without_namespace_spec.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+require "tmpdir"
+require "fileutils"
+require_relative "../../../../spec_helper"
+require "lutaml/xml/schema/xsd"
+
+# #1051: an xs:import without a namespace attribute is legal
+# (XSD 1.0 §3.13.2 — it imports a schema document with no target
+# namespace). The schema walk read the attribute store unguarded, so
+# a follow-up schema document carrying such an import crashed the
+# parse with "undefined method 'value' for nil".
+RSpec.describe "Xsd import without a namespace attribute" do
+  let(:dir) { Dir.mktmpdir }
+
+  before do
+    File.write(File.join(dir, "a.xsd"), <<~XSD)
+      <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+        <xs:import namespace="http://www.w3.org/XML/1998/namespace" schemaLocation="b.xsd"/>
+        <xs:element name="root"/>
+      </xs:schema>
+    XSD
+    File.write(File.join(dir, "b.xsd"), <<~XSD)
+      <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+        <xs:import schemaLocation="c.xsd"/>
+        <xs:attribute name="lang" type="xs:language"/>
+      </xs:schema>
+    XSD
+    File.write(File.join(dir, "c.xsd"), <<~XSD)
+      <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+        <xs:element name="helper"/>
+      </xs:schema>
+    XSD
+  end
+
+  after { FileUtils.remove_entry(dir) }
+
+  it "parses the whole chain" do
+    parsed = Lutaml::Xml::Schema::Xsd.parse(
+      File.read(File.join(dir, "a.xsd")),
+      location: dir,
+    )
+
+    expect(parsed).to be_a(Lutaml::Xml::Schema::Xsd::Schema)
+    expect(parsed.imports.first.schema_path).to eq("b.xsd")
+    expect(parsed.import.first).to be_a(Lutaml::Xml::Schema::Xsd::Schema)
+  end
+
+  it "keeps the namespace-less import unnamed" do
+    parsed = Lutaml::Xml::Schema::Xsd.parse(
+      <<~XSD,
+        <xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
+          <xs:import schemaLocation="c.xsd"/>
+        </xs:schema>
+      XSD
+      location: dir,
+    )
+
+    expect(parsed.imports.first.namespace).to be_nil
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.145
+  version: 0.8.147
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-28 00:00:00.000000000 Z
+date: 2026-10-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1990,6 +1990,7 @@ files:
 - spec/lutaml/xml/general_namespace_spec.rb
 - spec/lutaml/xml/html_entities_spec.rb
 - spec/lutaml/xml/indent_spec.rb
+- spec/lutaml/xml/leptris/plan_hydrator_ns_snapshot_spec.rb
 - spec/lutaml/xml/leptris_string_encoding_spec.rb
 - spec/lutaml/xml/line_ending_spec.rb
 - spec/lutaml/xml/mapping_finalization_guard_spec.rb
@@ -2054,6 +2055,7 @@ files:
 - spec/lutaml/xml/schema/xsd/errors/suggestion_spec.rb
 - spec/lutaml/xml/schema/xsd/file_validation_result_spec.rb
 - spec/lutaml/xml/schema/xsd/glob_spec.rb
+- spec/lutaml/xml/schema/xsd/import_without_namespace_spec.rb
 - spec/lutaml/xml/schema/xsd/keyref_refer_spec.rb
 - spec/lutaml/xml/schema/xsd/liquid_methods/attribute_and_group_spec.rb
 - spec/lutaml/xml/schema/xsd/liquid_methods/complex_type_spec.rb