lutaml-model 0.8.18 → 0.8.22

data/lib/compat/opal/generate_boot.rb

@@ -38,7 +38,9 @@ DECL_RE = /autoload\s+:[A-Za-z0-9_]+\s*,\s*"([^"]+)"/
 # DECL_RE can match. We only merge when the line ends right after the
 # comma that follows `autoload :Name`.
 def join_multiline_autoloads(src)
-  src.gsub(/(autoload\s+:[A-Za-z0-9_]+\s*,)\s*\n\s*/) { "#{Regexp.last_match(1)} " }
+  src.gsub(/(autoload\s+:[A-Za-z0-9_]+\s*,)\s*\n\s*/) do
+    "#{Regexp.last_match(1)} "
+  end
 end
 
 # Resolve an autoload's raw string argument to a require path relative to

data/lib/compat/opal/lutaml_model_boot.rb

@@ -21,22 +21,19 @@
 
 require "lutaml/model"
 require "lutaml/xml"
-require "lutaml/hash_format"
-require "lutaml/json"
-require "lutaml/jsonl"
 require "lutaml/jsonld"
-require "lutaml/key_value"
-require "lutaml/toml"
 require "lutaml/turtle"
-require "lutaml/yaml"
 require "lutaml/yamlld"
-require "lutaml/yamls"
 require "lutaml/hash_format/adapter"
+require "lutaml/hash_format/format"
+require "lutaml/json/format"
 require "lutaml/jsonl/adapter"
+require "lutaml/jsonl/format"
 require "lutaml/jsonld/adapter"
 require "lutaml/key_value/adapter"
 require "lutaml/key_value/data_model"
 require "lutaml/key_value/document"
+require "lutaml/key_value/format"
 require "lutaml/key_value/mapping"
 require "lutaml/key_value/mapping_rule"
 require "lutaml/key_value/transform"
@@ -103,6 +100,7 @@ require "lutaml/model/uninitialized_class"
 require "lutaml/model/union"
 require "lutaml/model/utils"
 require "lutaml/model/validation"
+require "lutaml/model/value_policy"
 require "lutaml/model/value_transformer"
 require "lutaml/model/version"
 require "lutaml/model/yaml"
@@ -121,6 +119,7 @@ require "lutaml/rdf/namespace_set"
 require "lutaml/rdf/namespaces"
 require "lutaml/rdf/term_definition"
 require "lutaml/rdf/transform"
+require "lutaml/toml/format"
 require "lutaml/turtle/adapter"
 require "lutaml/turtle/mapping"
 require "lutaml/turtle/transform"
@@ -143,6 +142,7 @@ require "lutaml/xml/document"
 require "lutaml/xml/element"
 require "lutaml/xml/element_prefix_resolver"
 require "lutaml/xml/encoding_normalizer"
+require "lutaml/xml/format"
 require "lutaml/xml/format_chooser"
 require "lutaml/xml/hoisting_algorithm"
 require "lutaml/xml/listener"
@@ -164,6 +164,7 @@ require "lutaml/xml/namespace_scope_config"
 require "lutaml/xml/namespace_type_resolver"
 require "lutaml/xml/namespace_usage"
 require "lutaml/xml/oga"
+require "lutaml/xml/parse_session"
 require "lutaml/xml/parsed_namespace_declaration"
 require "lutaml/xml/parsed_namespace_set"
 require "lutaml/xml/polymorphic_value_handler"
@@ -185,9 +186,11 @@ require "lutaml/xml/xml_attribute"
 require "lutaml/xml/xml_element"
 require "lutaml/xml/xsd_validator"
 require "lutaml/yaml/adapter"
+require "lutaml/yaml/format"
 require "lutaml/yaml/schema"
 require "lutaml/yamlld/adapter"
 require "lutaml/yamls/adapter"
+require "lutaml/yamls/format"
 require "lutaml/hash_format/adapter/document"
 require "lutaml/hash_format/adapter/mapping"
 require "lutaml/hash_format/adapter/mapping_rule"

data/lib/compat/opal/moxml_boot.rb

@@ -34,6 +34,10 @@ if RUBY_ENGINE == "opal"
   require "moxml/doctype"
   require "moxml/entity_reference"
   require "moxml/entity_registry"
+  require "moxml/entity"
+  require "moxml/entity/restorer"
+  require "moxml/entity/reference"
+  require "moxml/xml_emitter"
   require "moxml/adapter"
   require "moxml/adapter/base"
   require "moxml/adapter/customized_rexml"
@@ -46,10 +50,11 @@ if RUBY_ENGINE == "opal"
   require "moxml/sax/namespace_splitter"
   require "moxml/adapter/rexml"
   require "moxml/adapter/customized_oga"
+  require "moxml/adapter/customized_oga/entity_decoder"
+  require "moxml/adapter/customized_oga/raw_value_override"
   require "moxml/adapter/customized_oga/xml_declaration"
   require "moxml/adapter/customized_oga/xml_generator"
   require "moxml/adapter/oga"
-  require "moxml/document_builder"
   require "moxml/builder"
   require "moxml/context"
   require "moxml/config"

data/lib/lutaml/hash_format/format.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Internal Hash format implementation. Loaded from lib/lutaml/hash_format.rb
+# (the public entrypoint) and from lib/lutaml/model.rb (so the model
+# entrypoint triggers the registration side effects).
+# No require_relative "model" here — keeps the require graph acyclic.
+
+module Lutaml
+  module HashFormat
+    class Error < StandardError; end
+
+    autoload :Adapter, "#{__dir__}/adapter"
+  end
+end
+
+Lutaml::Model::FormatRegistry.register(
+  :hash,
+  mapping_class: Lutaml::HashFormat::Adapter::Mapping,
+  adapter_class: Lutaml::HashFormat::Adapter::StandardAdapter,
+  transformer: Lutaml::HashFormat::Adapter::Transform,
+  key_value: true,
+  adapter_options: {
+    available: %i[standard standard_hash],
+    default: :standard,
+  },
+)
+
+require_relative "type/serializers"
+Lutaml::HashFormat::Type::Serializers.register_all!

data/lib/lutaml/hash_format.rb

@@ -1,29 +1,7 @@
 # frozen_string_literal: true
 
-# Hash format module
-# Provides Lutaml::HashFormat namespace for Hash serialization
-
-module Lutaml
-  module HashFormat
-    class Error < StandardError; end
-
-    autoload :Adapter, "#{__dir__}/hash_format/adapter"
-  end
-end
-
-# Register Hash format with the format registry
-Lutaml::Model::FormatRegistry.register(
-  :hash,
-  mapping_class: Lutaml::HashFormat::Adapter::Mapping,
-  adapter_class: Lutaml::HashFormat::Adapter::StandardAdapter,
-  transformer: Lutaml::HashFormat::Adapter::Transform,
-  key_value: true,
-  adapter_options: {
-    available: %i[standard standard_hash],
-    default: :standard,
-  },
-)
-
-# Register Hash type serializers
-require_relative "hash_format/type/serializers"
-Lutaml::HashFormat::Type::Serializers.register_all!
+# Public Hash format entrypoint. Loads the base model and the internal
+# implementation. The internal file does not require the model back,
+# which keeps the require graph acyclic.
+require_relative "model"
+require_relative "hash_format/format"

data/lib/lutaml/json/format.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+# Internal JSON format implementation. Loaded from lib/lutaml/json.rb
+# (the public entrypoint) and from lib/lutaml/model.rb (so the model
+# entrypoint triggers the registration side effects).
+# No require_relative "model" here — keeps the require graph acyclic.
+
+require "lutaml/model/runtime_compatibility"
+require_relative "../key_value/format"
+
+module Lutaml
+  module Json
+    class Error < StandardError; end
+
+    require_relative "adapter/document"
+    require_relative "adapter/mapping"
+    require_relative "adapter/mapping_rule"
+    require_relative "adapter/transform"
+    require_relative "adapter/standard_adapter"
+    Lutaml::Model::RuntimeCompatibility.require_native(
+      "#{__dir__}/adapter/oj_adapter",
+      "#{__dir__}/adapter/multi_json_adapter",
+    )
+    require_relative "schema"
+
+    # Convenience aliases for common classes at the module level
+    # Allows Lutaml::Json::Mapping to resolve to Lutaml::Json::Adapter::Mapping
+    def self.const_missing(name)
+      if Adapter.const_defined?(name, false)
+        Adapter.const_get(name, false)
+      else
+        super
+      end
+    end
+
+    # Detect available JSON adapters
+    def self.detect_adapter
+      return :standard if defined?(::JSON) && Lutaml::Model.opal?
+      return :oj if defined?(::Oj)
+      return :multi_json if defined?(::MultiJson)
+      return :standard if defined?(::JSON)
+
+      nil
+    end
+  end
+end
+
+Lutaml::Model::FormatRegistry.register(
+  :json,
+  mapping_class: Lutaml::Json::Adapter::Mapping,
+  adapter_class: Lutaml::Json::Adapter::StandardAdapter,
+  transformer: Lutaml::Json::Adapter::Transform,
+  key_value: true,
+  adapter_options: {
+    available: %i[standard standard_json multi_json oj],
+    default: :standard,
+  },
+)
+
+require_relative "type/serializers"
+Lutaml::Json::Type::Serializers.register_all!

data/lib/lutaml/json.rb

@@ -1,62 +1,7 @@
 # frozen_string_literal: true
 
-# JSON format module
-# Provides Lutaml::Json namespace for JSON serialization
-
-require "lutaml/model/runtime_compatibility"
+# Public JSON format entrypoint. Loads the base model and the internal
+# implementation. The internal file does not require the model back,
+# which keeps the require graph acyclic.
 require_relative "model"
-require_relative "key_value"
-
-module Lutaml
-  module Json
-    class Error < StandardError; end
-
-    require_relative "json/adapter/document"
-    require_relative "json/adapter/mapping"
-    require_relative "json/adapter/mapping_rule"
-    require_relative "json/adapter/transform"
-    require_relative "json/adapter/standard_adapter"
-    Lutaml::Model::RuntimeCompatibility.require_native(
-      "#{__dir__}/json/adapter/oj_adapter",
-      "#{__dir__}/json/adapter/multi_json_adapter",
-    )
-    require_relative "json/schema"
-
-    # Convenience aliases for common classes at the module level
-    # Allows Lutaml::Json::Mapping to resolve to Lutaml::Json::Adapter::Mapping
-    def self.const_missing(name)
-      if Adapter.const_defined?(name, false)
-        Adapter.const_get(name, false)
-      else
-        super
-      end
-    end
-
-    # Detect available JSON adapters
-    def self.detect_adapter
-      return :standard if defined?(::JSON) && Lutaml::Model.opal?
-      return :oj if defined?(::Oj)
-      return :multi_json if defined?(::MultiJson)
-      return :standard if defined?(::JSON)
-
-      nil
-    end
-  end
-end
-
-# Register JSON format with the format registry
-Lutaml::Model::FormatRegistry.register(
-  :json,
-  mapping_class: Lutaml::Json::Adapter::Mapping,
-  adapter_class: Lutaml::Json::Adapter::StandardAdapter,
-  transformer: Lutaml::Json::Adapter::Transform,
-  key_value: true,
-  adapter_options: {
-    available: %i[standard standard_json multi_json oj],
-    default: :standard,
-  },
-)
-
-# Register JSON type serializers
-require_relative "json/type/serializers"
-Lutaml::Json::Type::Serializers.register_all!
+require_relative "json/format"

data/lib/lutaml/jsonl/format.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# Internal JSONL format implementation. Loaded from lib/lutaml/jsonl.rb
+# (the public entrypoint) and from lib/lutaml/model.rb (so the model
+# entrypoint triggers the registration side effects).
+# No require_relative "model" here — keeps the require graph acyclic.
+
+module Lutaml
+  module Jsonl
+    class Error < StandardError; end
+
+    autoload :Adapter, "#{__dir__}/adapter"
+  end
+end
+
+Lutaml::Model::FormatRegistry.register(
+  :jsonl,
+  mapping_class: Lutaml::Jsonl::Adapter::Mapping,
+  adapter_class: Lutaml::Jsonl::Adapter::StandardAdapter,
+  transformer: Lutaml::Jsonl::Adapter::Transform,
+  key_value: true,
+)

data/lib/lutaml/jsonl.rb

@@ -1,21 +1,7 @@
 # frozen_string_literal: true
 
-# JSONL format module
-# Provides Lutaml::Jsonl namespace for JSONL serialization
-
-module Lutaml
-  module Jsonl
-    class Error < StandardError; end
-
-    autoload :Adapter, "#{__dir__}/jsonl/adapter"
-  end
-end
-
-# Register JSONL format with the format registry
-Lutaml::Model::FormatRegistry.register(
-  :jsonl,
-  mapping_class: Lutaml::Jsonl::Adapter::Mapping,
-  adapter_class: Lutaml::Jsonl::Adapter::StandardAdapter,
-  transformer: Lutaml::Jsonl::Adapter::Transform,
-  key_value: true,
-)
+# Public JSONL format entrypoint. Loads the base model and the internal
+# implementation. The internal file does not require the model back,
+# which keeps the require graph acyclic.
+require_relative "model"
+require_relative "jsonl/format"

data/lib/lutaml/key_value/format.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+# Internal KeyValue implementation. Loaded from lib/lutaml/key_value.rb
+# (the public entrypoint) and from lib/lutaml/model.rb (so the model
+# entrypoint triggers the registration side effects).
+# No require_relative "model" here — keeps the require graph acyclic.
+
+module Lutaml
+  module KeyValue
+    autoload :DataModel, "#{__dir__}/data_model"
+    autoload :Document, "#{__dir__}/document"
+    autoload :Mapping, "#{__dir__}/mapping"
+    autoload :MappingRule, "#{__dir__}/mapping_rule"
+    autoload :Transform, "#{__dir__}/transform"
+    autoload :Transformation, "#{__dir__}/transformation"
+    autoload :TransformationBuilder, "#{__dir__}/transformation_builder"
+    autoload :Adapter, "#{__dir__}/adapter"
+  end
+end
+
+# Register KeyValue transformation builders for all key-value formats
+%i[json yaml toml hash].each do |format|
+  Lutaml::Model::TransformationRegistry.register_builder(
+    format, Lutaml::KeyValue::TransformationBuilder
+  )
+end

data/lib/lutaml/key_value/transform.rb

@@ -249,7 +249,10 @@ format)
         value = apply_value_map(value, rule.value_map(:from, options), attr)
 
         if rule.has_custom_method_for_deserialization?
-          return unless Lutaml::Model::Utils.present?(value)
+          # An empty value ("", [], {}) is a present value per the
+          # missing-values semantics and must reach the custom method;
+          # only nil (non-existent) skips it (lutaml-model#746).
+          return if value.nil?
 
           return rule.deserialize(instance, value, attributes, model_class)
         end

data/lib/lutaml/key_value/transformation/value_serializer.rb

@@ -88,11 +88,9 @@ model_class: nil)
         # @param rule [CompiledRule] The compiled rule
         # @return [Boolean] true if the rule defines a nested model
         def nested_model?(rule)
-          # rubocop:disable Style/IncludeOrExtend
           # Use include? instead of < because < returns nil (not false) for non-subclasses
           rule.attribute_type.is_a?(Class) &&
             rule.attribute_type.include?(Lutaml::Model::Serialize)
-          # rubocop:enable Style/IncludeOrExtend
         end
 
         # Serialize a nested model to a hash representation.

data/lib/lutaml/key_value.rb

@@ -1,24 +1,7 @@
 # frozen_string_literal: true
 
-module Lutaml
-  module KeyValue
-    autoload :DataModel, "#{__dir__}/key_value/data_model"
-    autoload :Document, "#{__dir__}/key_value/document"
-    autoload :Mapping, "#{__dir__}/key_value/mapping"
-    autoload :MappingRule, "#{__dir__}/key_value/mapping_rule"
-    autoload :Transform, "#{__dir__}/key_value/transform"
-    autoload :Transformation, "#{__dir__}/key_value/transformation"
-    autoload :TransformationBuilder,
-             "#{__dir__}/key_value/transformation_builder"
-    autoload :Adapter, "#{__dir__}/key_value/adapter"
-  end
-end
-
+# Public KeyValue entrypoint. Loads the base model and the internal
+# implementation. The internal file does not require the model back,
+# which keeps the require graph acyclic.
 require_relative "model"
-
-# Register KeyValue transformation builders for all key-value formats
-%i[json yaml toml hash].each do |format|
-  Lutaml::Model::TransformationRegistry.register_builder(
-    format, Lutaml::KeyValue::TransformationBuilder
-  )
-end
+require_relative "key_value/format"

data/lib/lutaml/model/attribute.rb

@@ -119,6 +119,17 @@ module Lutaml
         @resolver ||= GlobalContext.resolver
       end
 
+      # The value-shaping policy for this attribute. Constructed lazily so
+      # the collection/union/ref flags are settled; memoized because they
+      # are fixed after definition.
+      def value_policy
+        @value_policy ||= ValuePolicy.new(
+          collection: collection?,
+          union: union?,
+          reference: !@options[:ref_model_class].nil?,
+        )
+      end
+
       def type(context_or_register = nil)
         return if unresolved_type.nil?
 
@@ -394,7 +405,9 @@ instance_object = nil)
                                                           instance_object)
         elsif options[:default].is_a?(Proc)
           if instance_object
-            instance_object.instance_exec(&options[:default])
+            ::Lutaml::Model::Attribute.evaluating_default do
+              instance_object.instance_exec(&options[:default])
+            end
           else
             options[:default].call
           end
@@ -405,6 +418,22 @@ instance_object = nil)
         end
       end
 
+      # Marks the dynamic extent in which a default proc runs against a
+      # model instance, so Serialize#method_missing can fall back to the
+      # model class for methods the instance does not define (0.7.x
+      # compatibility, lutaml-model#745).
+      def self.evaluating_default
+        previous = Thread.current[:__lutaml_evaluating_default]
+        Thread.current[:__lutaml_evaluating_default] = true
+        yield
+      ensure
+        Thread.current[:__lutaml_evaluating_default] = previous
+      end
+
+      def self.default_evaluation?
+        Thread.current[:__lutaml_evaluating_default] == true
+      end
+
       def default_set?(register, instance_object = nil)
         !Utils.uninitialized?(default_value(register, instance_object))
       end
@@ -478,7 +507,10 @@ instance_object = nil)
         # Use the default value if the value is nil
         validate_required!(value)
 
-        value = cast_value(default_value(register, instance_object), register) if value.nil?
+        if value.nil?
+          value = cast_value(default_value(register, instance_object),
+                             register)
+        end
         resolved_type = type(register)
 
         valid_value!(value) &&
@@ -551,7 +583,8 @@ instance_object = nil)
       end
 
       def valid_collection!(value, caller)
-        if collection_instance?(value) && !collection?
+        if collection_instance?(value) && !collection? &&
+            !value_policy.whole_value?(unresolved_type)
           raise Lutaml::Model::CollectionTrueMissingError.new(name,
                                                               caller)
         end
@@ -632,7 +665,8 @@ instance_object = nil)
                         else
                           type(register)
                         end
-        if collection_instance?(value) || value.is_a?(Array)
+        if (collection_instance?(value) || value.is_a?(Array)) &&
+            !value_policy.whole_value?(resolved_type)
           merged_opts = options.merge(resolved_type: resolved_type,
                                       converted: true)
           return build_collection(value.map do |v|

data/lib/lutaml/model/collection.rb

@@ -481,8 +481,8 @@ lutaml_register: Lutaml::Model::Config.default_register)
         self.class.new(items - other.items)
       end
 
-      def each(&)
-        collection.each(&)
+      def each(&block)
+        collection.each(&block)
       end
 
       def size

data/lib/lutaml/model/compiled_rule.rb

@@ -192,7 +192,7 @@ module Lutaml
       # @param args [Array] Arguments (ignored for options)
       # @param block [Proc] Block (ignored for options)
       # @return [Object] The option value or nil
-      def method_missing(method_name, *args, &)
+      def method_missing(method_name, *args, &block)
         # Check if this is an option key
         if options.key?(method_name)
           return options[method_name]

data/lib/lutaml/model/config.rb

@@ -42,8 +42,8 @@ module Lutaml
       #   Config.with_adapter(xml: :nokogiri, toml: :tomlib) do
       #     MyModel.from_xml(data)
       #   end
-      def with_adapter(**overrides, &)
-        AdapterScope.with(overrides, &)
+      def with_adapter(**overrides, &block)
+        AdapterScope.with(overrides, &block)
       end
 
       # Delegate configure to Configuration

data/lib/lutaml/model/consolidation_map.rb

@@ -39,8 +39,8 @@ module Lutaml
         end
 
         # Pattern A: declare discriminator routing
-        def dispatch_by(discriminator, &)
-          routes = DispatchBuilder.new.evaluate(&)
+        def dispatch_by(discriminator, &block)
+          routes = DispatchBuilder.new.evaluate(&block)
           @rules << DispatchBlock.new(discriminator, routes)
         end
 

data/lib/lutaml/model/consolidation_rule/dispatch_block.rb

@@ -20,9 +20,9 @@ module Lutaml
 
     # Helper builder for the dispatch_by block
     class DispatchBuilder
-      def evaluate(&)
+      def evaluate(&block)
         @routes = {}
-        instance_eval(&)
+        instance_eval(&block)
         @routes
       end
 

data/lib/lutaml/model/errors.rb

@@ -18,8 +18,8 @@ module Lutaml
         @errors.empty?
       end
 
-      def each(&)
-        @errors.each(&)
+      def each(&block)
+        @errors.each(&block)
       end
 
       def full_messages

data/lib/lutaml/model/global_context.rb

@@ -436,8 +436,10 @@ context_id = nil)
             instance.register_for_namespace(namespace_uri)
           end
 
-          def resolve_type_with_namespace(type_name, namespace_uri = nil, context_id = nil)
-            instance.resolve_type_with_namespace(type_name, namespace_uri, context_id)
+          def resolve_type_with_namespace(type_name, namespace_uri = nil,
+context_id = nil)
+            instance.resolve_type_with_namespace(type_name, namespace_uri,
+                                                 context_id)
           end
 
           def namespace_register_map

data/lib/lutaml/model/mapping/mapping_rule.rb

@@ -67,6 +67,9 @@ module Lutaml
       )
         @name = name
         @to = to
+        # Dynamic symbol built per call allocated ~10% of parse objects on
+        # attribute-heavy documents; `to` is immutable, so build it once.
+        @setter_name = :"#{to}="
         @to_instance = to_instance
         @as_attribute = as_attribute
         @render_nil = render_nil
@@ -457,7 +460,7 @@ module Lutaml
       end
 
       def assign_value(model, value)
-        model.public_send(:"#{to}=", value)
+        model.public_send(@setter_name, value)
       end
     end
   end

data/lib/lutaml/model/mapping/model_mapping.rb

@@ -43,7 +43,7 @@ module Lutaml
         to: nil,
         transform: nil,
         reverse_transform: nil,
-        &
+        &block
       )
         map(
           from: from,
@@ -51,7 +51,7 @@ module Lutaml
           transform: transform,
           reverse_transform: reverse_transform,
           collection: true,
-          &
+          &block
         )
       end
 

data/lib/lutaml/model/runtime_compatibility.rb

@@ -114,8 +114,8 @@ if Lutaml::Model::RuntimeCompatibility.opal?
 
       # Minimal method_missing so the WeakRef quacks like its target
       # for the Store's index lookups.
-      def method_missing(name, *, &)
-        @__target__.public_send(name, *, &)
+      def method_missing(name, ...)
+        @__target__.public_send(name, ...)
       end
 
       def respond_to_missing?(name, include_private = false)

data/lib/lutaml/model/schema/class_loader.rb

@@ -36,7 +36,8 @@ module Lutaml
 
         def load
           Dir.mktmpdir do |dir|
-            FileWriter.write(@output, dir, registry_generator: @registry_generator)
+            FileWriter.write(@output, dir,
+                             registry_generator: @registry_generator)
             require File.join(dir, "#{registry_basename}_registry")
             call_register_all
           end