lutaml-model 0.8.103 → 0.8.105

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02366b5cf16f9598e6eae1c391d7b21002fe9744cc4d617bf4bb9ffc785141a8
-  data.tar.gz: b3e2928f228d2aa613e506c6b07ce70a765bb33d1574e61e871fd7f6d226ee43
+  metadata.gz: c9d133a4a89e51d9a1ed811bd992faeac4f0a8513e283b46f079707bcc083f7e
+  data.tar.gz: e4df7bb98a1f7518bdd9f2194934e91feea5367bbf536f75aa4353a067b65049
 SHA512:
-  metadata.gz: '096e5a0302f14999f0f0c33c5c08455cdea460bee145d0a2cbb222d5bf19157f931a8aecd9e99a2232e176db0a7c546b62908a91f851c083aedf75a4cbfb5993'
-  data.tar.gz: 79a62c6ce918c5ea416eec0a9343a9b52b65f5f9d7e234bcc94beaba817e2658d25ba680215ffaee282a8bfc4ba3f4d4fd2900ecfe5907c36f0ff317ec293028
+  metadata.gz: 7040ad58b0a31222207e14245293f8f20eb674180dcd55936de938151f16fc5260615f5ec3244769e4644af0bd6f02c9262e87717cbdff9d578a6b1365bbbb3a
+  data.tar.gz: f5d38407f6e5ad1b87bad426f68398a6e1249b57c928aa1a94f0585b144517542f0565c38ad2f53b31bc2c80bdaf63a5425968ba883c9d222508940f9b8b1c17

data/lib/lutaml/model/cached_type_resolver.rb

@@ -59,14 +59,14 @@ module Lutaml
       # updates so recursive type resolution can populate related keys.
       #
       # @param name [Symbol, String, Class] The type name or class to resolve
-      # @param context [TypeContext] The resolution context
+      # @param context [TypeContext, nil] The resolution context
       # @return [Class] The resolved type class
       # @raise [UnknownTypeError] If type cannot be resolved
       def resolve(name, context, materialize: true)
         return @delegate.resolve(name, context, materialize: false) unless materialize
 
         cache_key = if name.is_a?(Class)
-                      [context.id, name]
+                      [context_id_for(context), name]
                     else
                       build_cache_key(name, context)
                     end
@@ -79,11 +79,11 @@ module Lutaml
       # Check if a type can be resolved, using cache if available.
       #
       # @param name [Symbol, String, Class] The type name or class to check
-      # @param context [TypeContext] The resolution context
+      # @param context [TypeContext, nil] The resolution context
       # @return [Boolean] true if type can be resolved
       def resolvable?(name, context)
         cache_key = if name.is_a?(Class)
-                      [context.id, name]
+                      [context_id_for(context), name]
                     else
                       build_cache_key(name, context)
                     end
@@ -137,10 +137,17 @@ module Lutaml
       # Uses array for faster comparison than string concatenation.
       #
       # @param name [Symbol, String] The type name
-      # @param context [TypeContext] The resolution context
+      # @param context [TypeContext, nil] The resolution context
       # @return [Array] The cache key (faster than string)
       def build_cache_key(name, context)
-        [context.id, name.to_sym]
+        [context_id_for(context), name.to_sym]
+      end
+
+      # A nil context (e.g. a register ID that has no registered type
+      # context) is a legitimate "no namespace" resolution; the cache
+      # key just forgoes the namespace slot.
+      def context_id_for(context)
+        context&.id
       end
     end
   end

data/lib/lutaml/model/type_resolver.rb

@@ -44,7 +44,9 @@ module Lutaml
       # 5. Raise UnknownTypeError if not found anywhere
       #
       # @param name [Symbol, String, Class] The type name or class to resolve
-      # @param context [TypeContext] The resolution context
+      # @param context [TypeContext, nil] The resolution context (nil means
+      #   no primary registry and no fallbacks — an id registered in the
+      #   Register namespace but not as a type context)
       # @return [Class] The resolved type class
       # @raise [UnknownTypeError] If type cannot be resolved
       #
@@ -66,11 +68,11 @@ module Lutaml
         type_name = name.to_sym
 
         # 1. Check primary registry
-        type = context.lookup_local(type_name)
+        type = context&.lookup_local(type_name)
         return apply_substitutions(type, context) if type
 
         # 2. Check fallback contexts in order
-        if context.has_fallbacks?
+        if context&.has_fallbacks?
           context.fallback_contexts.each do |fallback_context|
             type = resolve_from_fallback(type_name, fallback_context)
             return apply_substitutions(type, context) if type
@@ -97,8 +99,8 @@ module Lutaml
         # 5. Type not found - raise error
         raise UnknownTypeError.new(
           type_name,
-          context_id: context.id,
-          available_types: available_type_names(context),
+          context_id: context&.id,
+          available_types: context ? available_type_names(context) : [],
         )
       end
 

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.103"
+    VERSION = "0.8.105"
   end
 end

data/lib/lutaml/xml/adapter/xml_parser.rb

@@ -20,10 +20,9 @@ module Lutaml
           raw_xml = xml
           xml = normalize_xml_for_parse(xml)
           parsed = parse_with_moxml(xml, parse_encoding)
-          assert_no_truncated_recovered_parse!(parsed)
           root_element = parsed.root
 
-          raise_empty_document_error if root_element.nil?
+          raise_empty_document_error(parsed.parse_errors) if root_element.nil?
 
           root = self::PARSED_ELEMENT_CLASS.new(root_element)
           doc_pis = extract_document_processing_instructions(parsed)
@@ -31,31 +30,6 @@ module Lutaml
           new(root, parse_encoding, **parse_document_options(raw_xml))
         end
 
-        # Recover-mode parsing must never masquerade input truncation as
-        # success.
-        #
-        # moxml releases before 0.5.84 parsed Nokogiri documents without
-        # XML_PARSE_HUGE, so libxml2 capped its input buffer at 10 MB;
-        # longer documents tripped a fatal "Resource limit exceeded:
-        # Buffer size limit exceeded, try XML_PARSE_HUGE" error mid-input.
-        # In recover mode Nokogiri records that error on the document and
-        # returns the partial tree, so every node past the limit silently
-        # vanishes (lutaml-model#871). A resource-limit fatal means the
-        # engine stopped early with input left — refuse to deserialize the
-        # partial document instead of dropping trailing content without a
-        # trace.
-        #
-        # moxml 0.5.84 and later always pass XML_PARSE_HUGE, so the
-        # Nokogiri path no longer truncates and this guard stays silent;
-        # it remains for older moxml releases and for any other adapter
-        # that reports the resource-limit family.
-        #
-        # Other recover-mode fatals (e.g. an XML declaration after leading
-        # whitespace) do not drop content and keep the long-standing
-        # recover behavior; only the resource-limit family is truncating.
-        TRUNCATION_FATAL_MARKER =
-          /Resource limit exceeded|Buffer size limit exceeded/
-
         private
 
         def normalize_xml_for_parse(xml)
@@ -88,23 +62,6 @@ module Lutaml
           end
         end
 
-        def assert_no_truncated_recovered_parse!(parsed)
-          errors = parsed.parse_errors
-          return if errors.nil? || errors.empty?
-
-          fatal = errors.find do |message|
-            message.match?(TRUNCATION_FATAL_MARKER)
-          end
-          return if fatal.nil?
-
-          raise Lutaml::Model::InvalidFormatError.new(
-            :xml,
-            "the XML engine reported a fatal resource limit and recovered " \
-            "with a truncated document; refusing to deserialize " \
-            "partial input (#{fatal})",
-          )
-        end
-
         def parse_document_options(xml)
           {
             doctype: extract_doctype_from_xml(xml),
@@ -112,8 +69,11 @@ module Lutaml
           }
         end
 
-        def raise_empty_document_error
+        def raise_empty_document_error(parse_errors = nil)
           message = self::EMPTY_DOCUMENT_ERROR_MESSAGE
+          if parse_errors && !parse_errors.empty?
+            message += " (the XML engine reported: #{parse_errors.join('; ')})"
+          end
 
           case self::EMPTY_DOCUMENT_ERROR_TYPE
           when :parse_exception

data/spec/lutaml/model/unregistered_context_resolution_spec.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+# Register ids and type-context ids are two namespaces that
+# GlobalContext#resolve_type bridges implicitly: an id present only in the
+# Register namespace (a flavor's `lutaml_default_register`) resolves to a
+# nil type context, and every resolution shape must treat that as a
+# legitimate "no namespace" input instead of crashing (metanorma-jis#531).
+RSpec.describe "type resolution through a register id with no registered type context" do
+  let(:collection_class) do
+    Class.new(Lutaml::Model::Collection) do
+      instances :entries, :string
+    end
+  end
+
+  it "resolves collection instance types under a nil context" do
+    collection = collection_class.new(["a"], lutaml_register: :jis_document)
+
+    expect(collection.entries).to eq(["a"])
+  end
+
+  it "resolves built-in symbol names under a nil context" do
+    resolved = Lutaml::Model::GlobalContext.resolve_type(:string, :jis_document)
+
+    expect(resolved).to eq(Lutaml::Model::Type::String)
+  end
+
+  it "raises UnknownTypeError for unknown names under a nil context" do
+    expect do
+      Lutaml::Model::GlobalContext.resolve_type(:no_such_type, :jis_document)
+    end.to raise_error(Lutaml::Model::UnknownTypeError)
+  end
+end

data/spec/lutaml/xml/adapter/empty_document_diagnostics_spec.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+require "lutaml/xml/adapter/leptris_adapter"
+require "lutaml/xml/adapter/nokogiri_adapter"
+
+# A failed parse reaches the empty-document guard as a document with no
+# root, indistinguishable from genuinely empty input. The engine's parse
+# diagnostics ride the document (moxml attachments :parse_errors) and
+# must surface in the raised message — otherwise the error names the
+# input's emptiness while the input is neither empty nor the problem
+# (lutaml-model#956).
+RSpec.describe "empty-document errors surface engine parse diagnostics" do
+  describe Lutaml::Xml::Adapter::LeptrisAdapter do
+    it "appends the engine diagnostic when the parse failed" do
+      expect do
+        described_class.parse("<root><a>x</b></root>")
+      end.to raise_error(Lutaml::Model::InvalidFormatError) do |error|
+        expect(error.message).to include("the XML engine reported:")
+        expect(error.message).to include("XML parse error at byte 14")
+      end
+    end
+
+    it "reports the engine diagnostic for whitespace-only input" do
+      expect do
+        described_class.parse("   ")
+      end.to raise_error(Lutaml::Model::InvalidFormatError, /the XML engine reported:/)
+    end
+  end
+
+  describe Lutaml::Xml::Adapter::NokogiriAdapter do
+    it "keeps the plain empty-document message when the engine reported nothing" do
+      expect do
+        described_class.parse("")
+      end.to raise_error(Lutaml::Model::InvalidFormatError) do |error|
+        expect(error.message).to include("The XML may be empty")
+        expect(error.message).not_to include("the XML engine reported:")
+      end
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lutaml-model
 version: !ruby/object:Gem::Version
-  version: 0.8.103
+  version: 0.8.105
 platform: ruby
 authors:
 - Ribose Inc.
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-10-11 00:00:00.000000000 Z
+date: 2026-10-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: base64
@@ -1863,6 +1863,7 @@ files:
 - spec/lutaml/model/uninitialized_class_spec.rb
 - spec/lutaml/model/union_attribute_spec.rb
 - spec/lutaml/model/union_spec.rb
+- spec/lutaml/model/unregistered_context_resolution_spec.rb
 - spec/lutaml/model/utils_spec.rb
 - spec/lutaml/model/validation/concerns/has_issues_spec.rb
 - spec/lutaml/model/validation/context_spec.rb
@@ -1913,6 +1914,7 @@ files:
 - spec/lutaml/turtle/mapping_spec.rb
 - spec/lutaml/turtle/transform_spec.rb
 - spec/lutaml/xml/adapter/base_adapter_regression_spec.rb
+- spec/lutaml/xml/adapter/empty_document_diagnostics_spec.rb
 - spec/lutaml/xml/adapter/nokogiri_adapter_spec.rb
 - spec/lutaml/xml/adapter/oga_adapter_spec.rb
 - spec/lutaml/xml/adapter/order_spec.rb