lutaml-model 0.8.19 → 0.8.22

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

data/lib/lutaml/model/schema/decorators/definition_collection.rb

@@ -21,12 +21,12 @@ module Lutaml
             resolve_polymorphic_base_types!
           end
 
-          def each(&)
-            @definitions.each(&)
+          def each(&block)
+            @definitions.each(&block)
           end
 
-          def transform_values(&)
-            @definitions.transform_values(&)
+          def transform_values(&block)
+            @definitions.transform_values(&block)
           end
 
           def [](name)

data/lib/lutaml/model/schema/definitions/namespace.rb

@@ -7,7 +7,8 @@ module Lutaml
         # An XML namespace declaration (subclass of
         # Lutaml::Xml::W3c::XmlNamespace).
         class Namespace
-          attr_accessor :class_name, :uri, :prefix_default, :element_form_default
+          attr_accessor :class_name, :uri, :prefix_default,
+                        :element_form_default
 
           def initialize(class_name:, uri:, prefix_default: nil,
                          element_form_default: nil)

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

@@ -45,7 +45,8 @@ module Lutaml
           )
           if registry
             registry_name = module_path.split("/").last
-            File.write(File.join(@dir, "#{registry_name}_registry.rb"), registry)
+            File.write(File.join(@dir, "#{registry_name}_registry.rb"),
+                       registry)
           end
 
           write_sources_to(full_dir)
@@ -57,7 +58,9 @@ module Lutaml
         end
 
         def write_sources_to(target_dir)
-          @output.sources.each { |name, src| write_source(target_dir, name, src) }
+          @output.sources.each do |name, src|
+            write_source(target_dir, name, src)
+          end
         end
 
         def write_source(target_dir, name, src)

data/lib/lutaml/model/schema/renderers/base.rb

@@ -10,11 +10,12 @@ module Lutaml
         # (Union, RestrictedType, Namespace). Model has its own constructor
         # because it computes an opt-out (module-wrappable) namespace.
         class Base
-          def self.render(spec, **)
-            new(spec, **).render
+          def self.render(spec, **options)
+            new(spec, **options).render
           end
 
-          def initialize(spec, indent: 2, module_namespace: nil, register_id: :default)
+          def initialize(spec, indent: 2, module_namespace: nil,
+register_id: :default)
             @spec = spec
             @indent = indent.is_a?(Integer) ? " " * indent : indent
             @extended_indent = @indent * 2

data/lib/lutaml/model/schema/renderers/mappings.rb

@@ -29,7 +29,9 @@ module Lutaml
           def render_one(member, indent)
             case member
             when Definitions::Sequence    then render_sequence(member, indent)
-            when Definitions::Choice      then member.alternatives.map { |a| render_one(a, indent) }.join
+            when Definitions::Choice      then member.alternatives.map do |a|
+              render_one(a, indent)
+            end.join
             when Definitions::Attribute   then render_attribute(member, indent)
             when Definitions::GroupImport then "#{indent}import_model_mappings :#{member.name}\n"
             end
@@ -37,7 +39,9 @@ module Lutaml
 
           def render_sequence(sequence, indent)
             inner_indent = indent + @base_indent
-            inner = sequence.members.map { |m| render_one(m, inner_indent) }.join
+            inner = sequence.members.map do |m|
+              render_one(m, inner_indent)
+            end.join
             "#{indent}sequence do\n#{inner}#{indent}end\n"
           end
 
@@ -63,7 +67,9 @@ module Lutaml
           def simple_content_attribute_mappings
             return "" unless @simple_content
 
-            @simple_content.additional_attributes.map { |a| render_one(a, @indent) }.join
+            @simple_content.additional_attributes.map do |a|
+              render_one(a, @indent)
+            end.join
           end
         end
       end