lutaml-model 0.8.19 → 0.8.23

data/lib/lutaml/model/schema/xml_compiler/element_order.rb

@@ -29,7 +29,8 @@ module Lutaml
               array.each_with_index do |element, i|
                 next unless element == builder
 
-                array[i] = Array(object.public_send(Utils.snake_case(builder.name)))[index]
+                array[i] =
+                  Array(object.public_send(Utils.snake_case(builder.name)))[index]
                 index += 1
               end
             end

data/lib/lutaml/model/schema/xml_compiler/spec_builder/complex_types.rb

@@ -25,7 +25,8 @@ module Lutaml
             def build(complex_type)
               model = Definitions::Model.new(
                 class_name: Utils.camel_case(complex_type.name),
-                xml_root: Definitions::XmlRoot.new(kind: :element, name: complex_type.name),
+                xml_root: Definitions::XmlRoot.new(kind: :element,
+                                                   name: complex_type.name),
                 mixed: !!complex_type.mixed,
                 namespace_class_name: @parent.namespace_class_name,
               )
@@ -49,7 +50,8 @@ module Lutaml
               base_name = group.name || Utils.last_of_split(group.ref)
               Definitions::Model.new(
                 class_name: Utils.camel_case(base_name),
-                xml_root: Definitions::XmlRoot.new(kind: :type_name, name: base_name),
+                xml_root: Definitions::XmlRoot.new(kind: :type_name,
+                                                   name: base_name),
                 members: inner_members,
                 module_wrappable: false,
                 lazy_register: true,

data/lib/lutaml/model/schema/xml_compiler/spec_builder/members.rb

@@ -56,7 +56,8 @@ module Lutaml
                 type: build_type_ref(resolve_element_type(element)),
                 xml_name: element.name,
                 kind: :element,
-                collection: collection_from_occurs(element.min_occurs, element.max_occurs),
+                collection: collection_from_occurs(element.min_occurs,
+                                                   element.max_occurs),
                 default: element.default,
                 render_default: !element.default.nil?,
                 render_empty: element_required?(element.min_occurs),
@@ -75,7 +76,9 @@ module Lutaml
             end
 
             def build_choice(choice)
-              alternatives = ElementOrder.resolved(choice).filter_map { |item| build_member(item) }
+              alternatives = ElementOrder.resolved(choice).filter_map do |item|
+                build_member(item)
+              end
               Definitions::Choice.new(
                 alternatives: alternatives,
                 header: choice_header(choice),
@@ -97,11 +100,18 @@ module Lutaml
             # ----- TypeRef ---------------------------------------------------
 
             def build_type_ref(raw_type)
-              return Definitions::TypeRef.new(kind: :symbol, value: "string") if raw_type.nil?
-              return Definitions::TypeRef.new(kind: :w3c, value: raw_type) if w3c_type?(raw_type)
+              if raw_type.nil?
+                return Definitions::TypeRef.new(kind: :symbol,
+                                                value: "string")
+              end
+              if w3c_type?(raw_type)
+                return Definitions::TypeRef.new(kind: :w3c,
+                                                value: raw_type)
+              end
 
               local = Utils.last_of_split(raw_type)
-              Definitions::TypeRef.new(kind: :symbol, value: Utils.snake_case(local))
+              Definitions::TypeRef.new(kind: :symbol,
+                                       value: Utils.snake_case(local))
             end
 
             private
@@ -131,7 +141,8 @@ module Lutaml
             def resolve_attribute_type(attr)
               return attr.type if attr.type
 
-              register_anonymous_simple_type("ST_#{attr.name}", attr.simple_type)
+              register_anonymous_simple_type("ST_#{attr.name}",
+                                             attr.simple_type)
             end
 
             def resolve_element_ref(element)
@@ -143,7 +154,8 @@ module Lutaml
                 type: target.type,
                 xml_name: target.xml_name,
                 kind: :element,
-                collection: collection_from_occurs(element.min_occurs, element.max_occurs),
+                collection: collection_from_occurs(element.min_occurs,
+                                                   element.max_occurs),
                 default: target.default,
                 render_default: !target.default.nil?,
                 render_empty: element_required?(element.min_occurs),
@@ -152,28 +164,42 @@ module Lutaml
 
             def resolve_element_type(element)
               return element.type if element.type
-              return register_anonymous_simple_type("ST_#{element.name}", element.simple_type) if element.simple_type
-              return register_anonymous_complex_type("CT_#{element.name}", element.complex_type) if element.complex_type
+              if element.simple_type
+                return register_anonymous_simple_type("ST_#{element.name}",
+                                                      element.simple_type)
+              end
+              if element.complex_type
+                return register_anonymous_complex_type("CT_#{element.name}",
+                                                       element.complex_type)
+              end
 
               "string"
             end
 
             def top_level_type_str(item)
               return item.type if item.respond_to?(:type) && item.type
-              return register_anonymous_simple_type("ST_#{item.name}", item.simple_type) if item.respond_to?(:simple_type) && item.simple_type
+              if item.respond_to?(:simple_type) && item.simple_type
+                return register_anonymous_simple_type("ST_#{item.name}",
+                                                      item.simple_type)
+              end
 
-              register_anonymous_complex_type("CT_#{item.name}", item.complex_type) if item.respond_to?(:complex_type) && item.complex_type
+              if item.respond_to?(:complex_type) && item.complex_type
+                register_anonymous_complex_type("CT_#{item.name}",
+                                                item.complex_type)
+              end
             end
 
             def register_anonymous_simple_type(anon_name, anon_node)
               anon_node.name = anon_name
-              @parent.simple_types[anon_name] = @parent.build_simple_type(anon_node)
+              @parent.simple_types[anon_name] =
+                @parent.build_simple_type(anon_node)
               anon_name
             end
 
             def register_anonymous_complex_type(anon_name, anon_node)
               anon_node.name = anon_name
-              @parent.complex_types[anon_name] = @parent.build_complex_type(anon_node)
+              @parent.complex_types[anon_name] =
+                @parent.build_complex_type(anon_node)
               anon_name
             end
 

data/lib/lutaml/model/schema/xml_compiler/spec_builder.rb

@@ -65,7 +65,9 @@ module Lutaml
             # passed :namespace, every generated complex type gets this
             # name. Mirrors XmlCompiler::ComplexType#setup_options on main.
             @namespace_class_name =
-              requested_uri && @namespace_classes.values.find { |ns| ns.uri == requested_uri }&.class_name
+              requested_uri && @namespace_classes.values.find do |ns|
+                ns.uri == requested_uri
+              end&.class_name
           end
 
           def walk_schemas(schemas)
@@ -79,11 +81,15 @@ module Lutaml
           end
 
           def collect_lookups(schemas)
-            each_schema_item(schemas) { |item, schema| dispatch_lookup(item, schema) }
+            each_schema_item(schemas) do |item, schema|
+              dispatch_lookup(item, schema)
+            end
           end
 
           def build_complex_types(schemas)
-            each_schema_item(schemas) { |item, schema| dispatch_complex(item, schema) }
+            each_schema_item(schemas) do |item, schema|
+              dispatch_complex(item, schema)
+            end
           end
 
           def dispatch_lookup(item, schema)
@@ -91,13 +97,17 @@ module Lutaml
             when Lutaml::Xml::Schema::Xsd::SimpleType
               @simple_types[item.name] = build_simple_type(item)
             when Lutaml::Xml::Schema::Xsd::Element
-              @elements[item.name] = @members_builder.build_top_level_attribute(item, kind: :element)
+              @elements[item.name] =
+                @members_builder.build_top_level_attribute(item, kind: :element)
             when Lutaml::Xml::Schema::Xsd::Attribute
               return if xml_defined_attribute?(schema, item.name)
 
-              @attributes[item.name] = @members_builder.build_top_level_attribute(item, kind: :attribute)
+              @attributes[item.name] =
+                @members_builder.build_top_level_attribute(item,
+                                                           kind: :attribute)
             when Lutaml::Xml::Schema::Xsd::AttributeGroup
-              @attribute_groups[item.name] = @complex_types_builder.build_attribute_group(item)
+              @attribute_groups[item.name] =
+                @complex_types_builder.build_attribute_group(item)
             end
           end
 
@@ -117,7 +127,8 @@ module Lutaml
               next if info[:skippable]
 
               str_name = name.to_s
-              @simple_types[str_name] = @simple_types_builder.build_supported(str_name, info)
+              @simple_types[str_name] =
+                @simple_types_builder.build_supported(str_name, info)
             end
           end
 
@@ -141,8 +152,13 @@ module Lutaml
           # Public surface used by the Members sub-builder to register
           # nested anonymous types it encounters during attribute /
           # element resolution.
-          def build_simple_type(simple_type) = @simple_types_builder.build(simple_type)
-          def build_complex_type(complex_type) = @complex_types_builder.build(complex_type)
+          def build_simple_type(simple_type)
+            @simple_types_builder.build(simple_type)
+          end
+
+          def build_complex_type(complex_type)
+            @complex_types_builder.build(complex_type)
+          end
 
           private
 
@@ -150,7 +166,10 @@ module Lutaml
           # yields each resolved element-order item with its owning schema.
           def each_schema_item(schemas, &dispatch)
             schemas.each do |schema|
-              each_schema_item(schema.include, &dispatch) if schema.include&.any?
+              if schema.include&.any?
+                each_schema_item(schema.include,
+                                 &dispatch)
+              end
               each_schema_item(schema.import, &dispatch)  if schema.import&.any?
               schema.resolved_element_order.each { |item| yield(item, schema) }
             end

data/lib/lutaml/model/schema/xml_compiler/supported_data_types.rb

@@ -59,8 +59,8 @@ module Lutaml
             TABLE[name]
           end
 
-          def each(&)
-            TABLE.each(&)
+          def each(&block)
+            TABLE.each(&block)
           end
 
           # `TypeRef.value` and `simple_content.base_class` ask the same

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

@@ -9,10 +9,12 @@ module Lutaml
       module XmlCompiler
         extend self
 
-        autoload :SpecBuilder,        "#{__dir__}/xml_compiler/spec_builder"
-        autoload :RegistryGenerator,  "#{__dir__}/xml_compiler/registry_generator"
-        autoload :SupportedDataTypes, "#{__dir__}/xml_compiler/supported_data_types"
-        autoload :ElementOrder,       "#{__dir__}/xml_compiler/element_order"
+        autoload :SpecBuilder, "#{__dir__}/xml_compiler/spec_builder"
+        autoload :RegistryGenerator,
+                 "#{__dir__}/xml_compiler/registry_generator"
+        autoload :SupportedDataTypes,
+                 "#{__dir__}/xml_compiler/supported_data_types"
+        autoload :ElementOrder, "#{__dir__}/xml_compiler/element_order"
 
         ELEMENT_ORDER_IGNORABLE = %w[import include].freeze
 
@@ -60,7 +62,10 @@ module Lutaml
             FileWriter.write(output, dir, registry_generator: RegistryGenerator)
             true
           else
-            ClassLoader.load(output, registry_generator: RegistryGenerator) if options[:load_classes]
+            if options[:load_classes]
+              ClassLoader.load(output,
+                               registry_generator: RegistryGenerator)
+            end
             output.sources
           end
         end

data/lib/lutaml/model/sequence.rb

@@ -27,12 +27,12 @@ module Lutaml
         @model.attribute(name, type, options)
       end
 
-      def sequence(&)
-        instance_eval(&)
+      def sequence(&block)
+        instance_eval(&block)
       end
 
-      def map_element(name, **)
-        @attributes << @model.map_element(name, **)
+      def map_element(name, **options)
+        @attributes << @model.map_element(name, **options)
       end
 
       def import_model_mappings(model, register = nil)

data/lib/lutaml/model/serialization_adapter.rb

@@ -17,7 +17,7 @@ module Lutaml
       end
 
       def self.parse(data, _options = {})
-        document_class.parse(data, create_additions: false)
+        document_class.parse(data)
       end
     end
   end

data/lib/lutaml/model/serialize/attribute_definition.rb

@@ -188,6 +188,7 @@ module Lutaml
 
           attr = Attribute.new(name, type, options)
           @attributes[name] = attr
+          @merged_attributes_cache = nil
           define_attribute_methods(attr)
 
           attr

data/lib/lutaml/model/serialize/format_conversion.rb

@@ -13,7 +13,7 @@ module Lutaml
         # @param format [Symbol] The format (:xml, :json, etc.)
         # @param args [Array] Additional arguments (e.g., mapping class for XML)
         # @param block [Proc] The DSL block to evaluate
-        def process_mapping(format, *_args, &)
+        def process_mapping(format, *_args, &block)
           klass = ::Lutaml::Model::Config.mappings_class_for(format)
           existing = mappings[format]
           mappings[format] = if existing.nil? || !existing.is_a?(klass)
@@ -21,7 +21,7 @@ module Lutaml
                              else
                                existing
                              end
-          mappings[format].instance_eval(&)
+          mappings[format].instance_eval(&block)
 
           if mappings[format].is_a?(Lutaml::Xml::Mapping)
             mappings[format].finalize(self)
@@ -192,24 +192,55 @@ module Lutaml
         #   is always preserved when available, regardless of this option.
         # @return [String] The serialized output
         def to(format, instance, options = {})
+          # Ruby's JSON generator hands #to_json its own JSON::State rather
+          # than an options hash. It carries no LutaML options, but it does
+          # carry the surrounding indent context, so it is forwarded to the
+          # adapter unchanged instead of being read like a Hash -- json 3.0
+          # removed JSON::State#[].
+          options = Serialize.wrap_generator_state(options)
+          generator_state = options.delete(Serialize::GENERATOR_STATE_KEY)
+
           Instrumentation.instrument(:to, model: name, format: format) do
-            adapter_override = options.is_a?(Hash) && options.delete(:adapter)
-            if adapter_override && options.is_a?(Hash)
-              options[:_adapter_override] =
-                true
-            end
+            adapter_override = options.delete(:adapter)
+            options[:_adapter_override] = true if adapter_override
             value = public_send(:"as_#{format}", instance, options)
             adapter = resolve_adapter(format, adapter_override)
 
             # Hook for format-specific options preparation (e.g., XML prefix/namespace/declaration)
             options = prepare_to_options(format, instance, options)
 
-            adapter.new(value, register: options[:register]).public_send(
-              :"to_#{format}", options
+            document = adapter.new(value, register: options[:register])
+
+            document.public_send(
+              :"to_#{format}",
+              forward_options(document, generator_state, options),
             )
           end
         end
 
+        # Main's behaviour differs per ADAPTER, not per option, so this follows
+        # the adapter rather than trying to translate option names:
+        #   stdlib  honours script_safe / ascii_only / pretty -> give it the state
+        #   Oj      ignores them all and uses its own escape_mode -> give it none
+        #   others  reach the stdlib generator underneath -> give them the options
+        def forward_options(document, generator_state, options)
+          return options if generator_state.nil?
+
+          if declares?(document, :accepts_generator_state?)
+            generator_state
+          elsif declares?(document, :ignores_generator_options?)
+            options
+          elsif generator_state.respond_to?(:to_h)
+            options.merge(generator_state.to_h)
+          else
+            options
+          end
+        end
+
+        def declares?(document, predicate)
+          document.respond_to?(predicate) && document.public_send(predicate)
+        end
+
         # Hook for format-specific options preparation before serialization.
         # XML overrides to handle prefix, namespace overrides, declaration plan.
         #

data/lib/lutaml/model/serialize/initialization.rb

@@ -115,13 +115,18 @@ module Lutaml
         # Get all attributes for this model
         #
         # Merges class-level attributes with register-specific attributes.
+        # Memoized per register: this is on the per-element deserialization
+        # hot path, and the merged hash is stable until an attribute, import
+        # or register record mutates (those clear @merged_attributes_cache).
         #
         # @param register [Symbol, nil] The register context
         # @return [Hash] The attributes hash
         def attributes(register = nil)
           ensure_imports!(register) if finalized?
           if @register_records&.any?
-            @attributes.merge(@register_records[extract_register_id(register)][:attributes])
+            register_id = extract_register_id(register)
+            (@merged_attributes_cache ||= {})[register_id] ||=
+              @attributes.merge(@register_records[register_id][:attributes])
           else
             @attributes
           end
@@ -183,6 +188,9 @@ module Lutaml
             GlobalContext.resolver.clear_cache(register_id)
           end
 
+          # Clear memoized attribute merge (see .attributes)
+          @merged_attributes_cache = nil
+
           # Clear per-Attribute type caches (stale entries from GC'd TypeContext objects)
           class_attributes.each_value(&:clear_type_cache)
           @register_records&.each_value do |record|

data/lib/lutaml/model/serialize/model_import.rb

@@ -121,6 +121,7 @@ module Lutaml
           @register_records[register_id][:choice_attributes].concat(
             deep_duplicate_choice_attributes(model, register_id),
           )
+          @merged_attributes_cache = nil
         end
         private :register_only_import_model_attributes
 

data/lib/lutaml/model/serialize.rb

@@ -175,18 +175,19 @@ module Lutaml
         @using_default[attribute_name]
       end
 
-      # rubocop:disable Style/ArgumentsForwarding -- anonymous * requires Ruby 3.2+, but required_ruby_version >= 3.0
-      def method_missing(method_name, *args)
+      def method_missing(method_name, *args, &block)
         if method_name.to_s.end_with?("=") && attribute_exist?(method_name)
           define_singleton_method(method_name) do |value|
             instance_variable_set(:"@#{method_name.to_s.chomp('=')}", value)
           end
           send(method_name, *args)
+        elsif ::Lutaml::Model::Attribute.default_evaluation? &&
+            self.class.respond_to?(method_name)
+          self.class.public_send(method_name, *args, &block)
         else
           super
         end
       end
-      # rubocop:enable Style/ArgumentsForwarding
 
       def respond_to_missing?(method_name, include_private = false)
         (method_name.to_s.end_with?("=") && attribute_exist?(method_name)) ||
@@ -224,7 +225,25 @@ module Lutaml
         self.class.as_yaml(self)
       end
 
+      # Ruby's JSON generator hands #to_json its own JSON::State instead of an
+      # options hash. It carries no LutaML options, but it does carry the
+      # surrounding indent context, so it travels IN BAND under a private key
+      # rather than replacing the options hash. Wrapping rather than returning
+      # early keeps every later step -- register propagation, root-mapping
+      # validation, Collection's `collection: true` merge -- working on a real
+      # Hash. json 3.0 removed JSON::State#[] and rejects unknown keys in
+      # State#merge, so nothing may treat it as a Hash.
+      GENERATOR_STATE_KEY = :_generator_state
+
+      def self.wrap_generator_state(options)
+        return options if options.is_a?(::Hash)
+
+        { GENERATOR_STATE_KEY => options }
+      end
+
       def to_format(format, options = {})
+        options = Lutaml::Model::Serialize.wrap_generator_state(options)
+
         # Hook for format-specific validation (e.g., XML root mapping check)
         validate_root_mapping!(format, options)
 

data/lib/lutaml/model/transformation.rb

@@ -37,9 +37,14 @@ module Lutaml
         @format = format
         @register = register
         @compiled_rules = compile_rules(mapping_dsl)
+        after_compile
         freeze
       end
 
+      # Hook for format subclasses to derive rule-set-level data after
+      # compilation, before the transformation is frozen and shared.
+      def after_compile; end
+
       # Transform a model instance into format-specific representation
       #
       # @abstract Subclasses must implement this method

data/lib/lutaml/model/type/uninitialized_class_guard.rb

@@ -17,7 +17,7 @@ module Lutaml
         #
         # The prepend ensures this method runs BEFORE the subclass's
         # cast implementation, even if the subclass doesn't call super.
-        def cast(value, *args, **kwargs, &)
+        def cast(value, *args, **kwargs, &block)
           # Return UninitializedClass unchanged - don't transform it
           return value if Utils.uninitialized?(value)
 

data/lib/lutaml/model/type.rb

@@ -55,7 +55,16 @@ module Lutaml
         hex_binary: "Lutaml::Model::Type::HexBinary",
       }.freeze
 
+      BUILTIN_CLASSES =
+        TYPE_CODES.each_value.map { |type_class_name| const_get(type_class_name) }.freeze
+
       class << self
+        # @param type [Class] a candidate type class
+        # @return [Boolean] whether the class is one of the built-ins
+        def builtin?(type)
+          BUILTIN_CLASSES.include?(type)
+        end
+
         # Register all built-in types into any TypeRegistry.
         #
         # This method is used by the new type resolution architecture.

data/lib/lutaml/model/type_registry.rb

@@ -127,8 +127,8 @@ module Lutaml
       #
       # @example
       #   registry.each { |name, klass| puts "#{name}: #{klass}" }
-      def each(&)
-        @types.each(&)
+      def each(&block)
+        @types.each(&block)
       end
 
       # Create a copy of this registry

data/lib/lutaml/model/uninitialized_class.rb

@@ -48,7 +48,7 @@ module Lutaml
         "".encoding
       end
 
-      def method_missing(method, *_args, &)
+      def method_missing(method, *_args)
         return false if method.end_with?("?")
 
         nil

data/lib/lutaml/model/union.rb

@@ -131,7 +131,8 @@ module Lutaml
 
           def validate_members!(members)
             unless members.is_a?(::Array) && !members.empty?
-              raise ArgumentError, "union type must be a non-empty array of types"
+              raise ArgumentError,
+                    "union type must be a non-empty array of types"
             end
 
             resolved = members.map { |member| resolve_member!(member) }
@@ -166,7 +167,9 @@ module Lutaml
             return :no_match if keys.nil? || keys.empty?
 
             field_names = member_field_names(member, format, register)
-            return :no_match unless keys.all? { |key| field_names.include?(key) }
+            return :no_match unless keys.all? do |key|
+              field_names.include?(key)
+            end
 
             # Plain-Ruby assignment (format nil) builds straight from the
             # attribute hash, mirroring how non-union model attributes accept

data/lib/lutaml/model/utils.rb

@@ -201,10 +201,10 @@ module Lutaml
           end
         end
 
-        def add_singleton_method_if_not_defined(instance, method_name, &)
+        def add_singleton_method_if_not_defined(instance, method_name, &block)
           return if instance.singleton_class.method_defined?(method_name, false)
 
-          instance.define_singleton_method(method_name, &)
+          instance.define_singleton_method(method_name, &block)
         end
 
         # Determines the appropriate register for a child model during deserialization.

data/lib/lutaml/model/value_policy.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Lutaml
+  module Model
+    # Decides how an attribute shapes incoming raw values: whether an
+    # Array is split element-wise (collection semantics) or handed whole
+    # to the declared type (value-owning semantics).
+    #
+    # A user-defined Type::Value subclass may legitimately wrap lists or
+    # maps in a singular slot (#752); built-in scalar types keep the
+    # "collection: true is missing" guidance error.
+    class ValuePolicy
+      def initialize(collection:, union:, reference:)
+        @collection = collection
+        @union = union
+        @reference = reference
+      end
+
+      # @param type [Class, Symbol] the resolved (or unresolved) type
+      # @return [Boolean] whether raw values must reach the type whole
+      def whole_value?(type)
+        !@collection && !@union && !@reference &&
+          type.is_a?(Class) && type < Type::Value && !Type.builtin?(type)
+      end
+    end
+  end
+end

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.8.19"
+    VERSION = "0.8.23"
   end
 end