lutaml-model 0.8.19 → 0.9.1

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

@@ -14,7 +14,8 @@ module Lutaml
             new(spec, **).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
@@ -39,8 +40,15 @@ module Lutaml
 
           def rendered_class_name = @spec.class_name
           def serializable_class_parent = @spec.parent_class
-          def serializable_class_required_files = format_files(@spec.required_files)
-          def serializable_class_documentation = format_doc_block(@spec.documentation)
+
+          def serializable_class_required_files
+            format_files(@spec.required_files)
+          end
+
+          def serializable_class_documentation
+            format_doc_block(@spec.documentation)
+          end
+
           def serializable_class_imports = render_imports
 
           def serializable_class_attributes
@@ -76,7 +84,11 @@ module Lutaml
           end
 
           def xml_mixed_content? = @spec.mixed
-          def xml_text_content? = @spec.text_content || !!@spec.simple_content || @spec.mixed
+
+          def xml_text_content?
+            @spec.text_content || !!@spec.simple_content || @spec.mixed
+          end
+
           def xml_extra_mappings = ""
 
           def module_opening = ModuleNesting.opening(modules)

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

@@ -34,7 +34,8 @@ module Lutaml
             Definitions::MemberWalk.each_attribute(model.members) do |attr|
               deps.concat(xml_attribute_requires(attr, skippable_type))
             end
-            deps.concat(simple_content_requires(model.simple_content, skippable_type))
+            deps.concat(simple_content_requires(model.simple_content,
+                                                skippable_type))
             deps << namespace_require(model.namespace_class_name) if model.namespace_class_name
             deps.uniq
           end

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

@@ -6,7 +6,8 @@ module Lutaml
       module Renderers
         autoload :Base,         "#{__dir__}/renderers/base"
         autoload :Registration, "#{__dir__}/renderers/registration"
-        autoload :RequiredFilesCalculator, "#{__dir__}/renderers/required_files_calculator"
+        autoload :RequiredFilesCalculator,
+                 "#{__dir__}/renderers/required_files_calculator"
         autoload :MemberDecls,    "#{__dir__}/renderers/member_decls"
         autoload :Mappings,       "#{__dir__}/renderers/mappings"
         autoload :Model,          "#{__dir__}/renderers/model"

data/lib/lutaml/model/schema/rnc_compiler/source_resolver.rb

@@ -20,9 +20,13 @@ module Lutaml
             if File.file?(expanded)
               return file_source(expanded) if input.nil? || input.to_s.empty?
 
-              return string_source(input, base_dir: File.dirname(expanded), path: expanded)
+              return string_source(input, base_dir: File.dirname(expanded),
+                                          path: expanded)
+            end
+            if File.directory?(expanded)
+              return string_source(input,
+                                   base_dir: expanded)
             end
-            return string_source(input, base_dir: expanded) if File.directory?(expanded)
 
             string_source(input)
           end

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

@@ -47,7 +47,9 @@ module Lutaml
         # the 0.3.7 release; the released parse_rnc takes only `(rnc)`.
         def rnc_parser_available?
           defined?(::Rng::Grammar) && ::Rng.respond_to?(:parse_rnc) &&
-            ::Rng.method(:parse_rnc).parameters.any? { |_type, name| name == :location }
+            ::Rng.method(:parse_rnc).parameters.any? do |_type, name|
+              name == :location
+            end
         end
 
         def default_output_dir

data/lib/lutaml/model/schema/rng_compiler/element_visitor.rb

@@ -23,8 +23,10 @@ module Lutaml
           ].freeze
 
           REPETITION_CTX = {
-            zeroOrMore: { collection: (0..Float::INFINITY), initialize_empty: true },
-            oneOrMore: { collection: (1..Float::INFINITY), initialize_empty: true },
+            zeroOrMore: { collection: (0..Float::INFINITY),
+                          initialize_empty: true },
+            oneOrMore: { collection: (1..Float::INFINITY),
+                         initialize_empty: true },
             list: { collection: (0..Float::INFINITY), initialize_empty: true },
           }.freeze
 
@@ -60,7 +62,8 @@ module Lutaml
             class_name = Utils.camel_case(element.attr_name)
             model = @classes[class_name] ||= Definitions::Model.new(
               class_name: class_name,
-              xml_root: Definitions::XmlRoot.new(kind: :element, name: element.attr_name),
+              xml_root: Definitions::XmlRoot.new(kind: :element,
+                                                 name: element.attr_name),
               documentation: documentation_text(element),
               namespace_class_name: namespace_class_for(element),
             )
@@ -90,7 +93,8 @@ module Lutaml
             wrapping = define.element.size == 1 ? define.element.first : nil
 
             xml_root = if wrapping
-                         Definitions::XmlRoot.new(kind: :element, name: wrapping.attr_name)
+                         Definitions::XmlRoot.new(kind: :element,
+                                                  name: wrapping.attr_name)
                        else
                          Definitions::XmlRoot.new(kind: :fragment)
                        end
@@ -198,22 +202,30 @@ module Lutaml
             doc = documentation_text(child)
             value_type = @value_type_resolver.resolve(child)
             type_ref = type_ref_for_element(child, value_type)
-            push_attribute(parent, build_attribute(child, type_ref, :element, ctx, doc))
+            push_attribute(parent,
+                           build_attribute(child, type_ref, :element, ctx, doc))
           end
 
           def type_ref_for_element(child, value_type)
-            return Definitions::TypeRef.new(kind: :symbol, value: value_type.to_s) if value_type
+            if value_type
+              return Definitions::TypeRef.new(kind: :symbol,
+                                              value: value_type.to_s)
+            end
 
             compiled = compile_element(child)
-            Definitions::TypeRef.new(kind: :class_ref, value: compiled.class_name)
+            Definitions::TypeRef.new(kind: :class_ref,
+                                     value: compiled.class_name)
           end
 
           def handle_attribute(_kind, child, parent, ctx)
             doc = documentation_text(child)
             symbol = attribute_type_symbol(child)
-            type_ref = Definitions::TypeRef.new(kind: :symbol, value: symbol.to_s)
+            type_ref = Definitions::TypeRef.new(kind: :symbol,
+                                                value: symbol.to_s)
             fixed = fixed_value_default(child)
-            push_attribute(parent, build_attribute(child, type_ref, :attribute, ctx, doc, default: fixed))
+            push_attribute(parent,
+                           build_attribute(child, type_ref, :attribute, ctx,
+                                           doc, default: fixed))
           end
 
           # The attribute's value type, as a Symbol. An attribute in a foreign
@@ -225,7 +237,8 @@ module Lutaml
             uri = foreign_namespace_uri(child)
             return base unless uri
 
-            namespaced_attribute_type(child, base, @register_namespace.call(uri))
+            namespaced_attribute_type(child, base,
+                                      @register_namespace.call(uri))
           end
 
           # Give the attribute's value a namespace via a dedicated generated
@@ -300,19 +313,26 @@ module Lutaml
 
           def handle_ref(_kind, ref, parent, ctx)
             target_define = @defines[ref.name]
-            raise Lutaml::Model::Error, "ref to unknown define: #{ref.name}" unless target_define
+            unless target_define
+              raise Lutaml::Model::Error,
+                    "ref to unknown define: #{ref.name}"
+            end
 
             target_class = compile_define(target_define)
 
             if RngHelpers.simple_type?(target_class)
-              type_ref = Definitions::TypeRef.new(kind: :symbol, value: RngHelpers.type_symbol(target_class.class_name).to_s)
-              push_attribute(parent, build_ref_attribute(ref, type_ref, ref.name, ctx))
+              type_ref = Definitions::TypeRef.new(kind: :symbol,
+                                                  value: RngHelpers.type_symbol(target_class.class_name).to_s)
+              push_attribute(parent,
+                             build_ref_attribute(ref, type_ref, ref.name, ctx))
             elsif RngHelpers.fragment_model?(target_class) && ctx[:collection].nil?
               push_import(parent, target_class.class_name)
             else
-              type_ref = Definitions::TypeRef.new(kind: :class_ref, value: target_class.class_name)
+              type_ref = Definitions::TypeRef.new(kind: :class_ref,
+                                                  value: target_class.class_name)
               xml_name = target_class.xml_root.name || ref.name
-              push_attribute(parent, build_ref_attribute(ref, type_ref, xml_name, ctx))
+              push_attribute(parent,
+                             build_ref_attribute(ref, type_ref, xml_name, ctx))
             end
           end
 

data/lib/lutaml/model/schema/rng_compiler/value_type_resolver.rb

@@ -57,14 +57,16 @@ module Lutaml
             base = RngCompiler::DATA_TYPE_MAP.fetch(
               data.type, RngCompiler::DEFAULT_DATA_TYPE
             )
-            anonymous_restricted_type(container, base, RngHelpers.facet_from_data(data))
+            anonymous_restricted_type(container, base,
+                                      RngHelpers.facet_from_data(data))
           end
 
           def anonymous_from_enum_choice(container)
             choice = RngHelpers.single(container.choice)
             return nil unless choice && RngHelpers.pure_value_choice?(choice)
 
-            anonymous_restricted_type(container, :string, RngHelpers.facet_from_values(choice.value))
+            anonymous_restricted_type(container, :string,
+                                      RngHelpers.facet_from_values(choice.value))
           end
 
           def anonymous_restricted_type(container, base, facet)

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

@@ -20,8 +20,9 @@ module Lutaml
         autoload :MemberCollector,   "#{__dir__}/rng_compiler/member_collector"
         autoload :ElementVisitor,    "#{__dir__}/rng_compiler/element_visitor"
         autoload :DefineClassifier,  "#{__dir__}/rng_compiler/define_classifier"
-        autoload :ValueTypeResolver, "#{__dir__}/rng_compiler/value_type_resolver"
-        autoload :RngHelpers,        "#{__dir__}/rng_compiler/rng_helpers"
+        autoload :ValueTypeResolver,
+                 "#{__dir__}/rng_compiler/value_type_resolver"
+        autoload :RngHelpers, "#{__dir__}/rng_compiler/rng_helpers"
 
         # Map RNG <data type="..."/> values to Lutaml::Model attribute type
         # symbols. Mirrors Lutaml::Xml::Schema::RelaxngSchema.get_relaxng_type
@@ -59,7 +60,9 @@ module Lutaml
           classes, namespaces = compile_grammar(grammar)
 
           entries =
-            classes.map { |name, spec| CompiledOutput::Entry.new(name, spec, :model) } +
+            classes.map do |name, spec|
+              CompiledOutput::Entry.new(name, spec, :model)
+            end +
             namespaces.map { |name, spec| CompiledOutput::Entry.new(name, spec, :namespace) }
 
           CompiledOutput.new(
@@ -89,7 +92,8 @@ module Lutaml
           return rng if rng.is_a?(::Rng::Grammar)
 
           if options[:location]
-            ::Rng.parse(rng, location: options[:location], resolve_external: true)
+            ::Rng.parse(rng, location: options[:location],
+                             resolve_external: true)
           else
             ::Rng::Grammar.from_xml(rng)
           end
@@ -165,7 +169,8 @@ module Lutaml
           ns = Definitions::Namespace.new(
             class_name: class_name,
             uri: uri,
-            prefix_default: unique_prefix(namespaces, NamespaceNaming.prefix_for(uri)),
+            prefix_default: unique_prefix(namespaces,
+                                          NamespaceNaming.prefix_for(uri)),
             element_form_default: :qualified,
           )
           namespaces[class_name] = ns

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.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/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/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, *, &)
         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)
+          send(method_name, *)
+        elsif ::Lutaml::Model::Attribute.default_evaluation? &&
+            self.class.respond_to?(method_name)
+          self.class.public_send(method_name, *, &)
         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)) ||

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/version.rb

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