lutaml-model 0.8.103 → 0.8.104

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 02366b5cf16f9598e6eae1c391d7b21002fe9744cc4d617bf4bb9ffc785141a8
-  data.tar.gz: b3e2928f228d2aa613e506c6b07ce70a765bb33d1574e61e871fd7f6d226ee43
+  metadata.gz: bd4d3ab0b184df92ad1d6ef04af5e1e1af9d483d34902f36d94b010477c54841
+  data.tar.gz: 6e5eee3bebcf1b9557b1cf635253b322a5dffc31fcbe1c7e3b07a76143a2100f
 SHA512:
-  metadata.gz: '096e5a0302f14999f0f0c33c5c08455cdea460bee145d0a2cbb222d5bf19157f931a8aecd9e99a2232e176db0a7c546b62908a91f851c083aedf75a4cbfb5993'
-  data.tar.gz: 79a62c6ce918c5ea416eec0a9343a9b52b65f5f9d7e234bcc94beaba817e2658d25ba680215ffaee282a8bfc4ba3f4d4fd2900ecfe5907c36f0ff317ec293028
+  metadata.gz: 761158fee8d42f919236179a76b90116183afde1cc7e8beb6921c958c27d03c96a6ada9a04abc0959417e34f1ca7677e99b33c00ef38326fe10cf196c0010e4f
+  data.tar.gz: 96f3e592216d1f0fe4bc6274ea92006e8db8fb67d77b31dbe79868175d1a42cfa17145ea9ac981d2ba6aaecf9cf9888260a1a33675f6aa7b735667d275270e23

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.104"
   end
 end

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

@@ -23,7 +23,7 @@ module Lutaml
           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)
@@ -112,8 +112,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.104
 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