lutaml-model 0.8.17 → 0.8.19

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

@@ -108,31 +108,34 @@ module Lutaml
                 current = instance_variable_get(:"@#{name}") || []
                 new_value = current.is_a?(Array) ? current + [value] : value
                 instance_variable_set(:"@#{name}", new_value)
-                # Track order for mixed_content serialization
-                track_order(name, value, nil) if @__order_tracking__
+                record_mutation(name, value)
                 value
               end
             end
           else
             # For non-collection attributes, getter accepts optional argument
-            # for builder-style syntax: g.description(value) sets the value
+            # for builder-style syntax: g.description(value) sets the value.
+            # Tracking happens inside the setter, so no duplicate call here.
             define_method(name) do |*args|
               if args.empty?
                 instance_variable_get(:"@#{name}")
               else
-                # Builder-style: g.description(value) sets the value
-                value = args.first
-                public_send(:"#{name}=", value)
-                # Track order for mixed_content serialization
-                track_order(name, value, nil) if @__order_tracking__
-                value
+                public_send(:"#{name}=", args.first)
+                args.first
               end
             end
           end
 
           enum_shorthand_names = instance_variable_get(:@__enum_shorthand_names__) || Set.new
-          unless method_defined?(:"#{name}=",
-                                 false) && !enum_shorthand_names.include?(name.to_s)
+          # Opal's Module#method_defined? only accepts 1 arg (MRI accepts
+          # the optional `inherit` flag). Skip the flag there — the
+          # difference only matters for inherited-method filtering.
+          setter_defined = if Lutaml::Model.opal?
+                             method_defined?(:"#{name}=")
+                           else
+                             method_defined?(:"#{name}=", false)
+                           end
+          unless setter_defined && !enum_shorthand_names.include?(name.to_s)
             if attr.collection?
               define_method(:"#{name}=") do |value|
                 value_set_for(name)
@@ -149,12 +152,16 @@ module Lutaml
                 else
                   instance_variable_set(:"@#{name}", value)
                 end
+                # Track one entry per item so element_order reflects the
+                # number of <name> elements that will be emitted.
+                record_mutation_collection(name, value)
               end
             else
               define_method(:"#{name}=") do |value|
                 value_set_for(name)
                 value = attr.cast_value(value, lutaml_register)
                 instance_variable_set(:"@#{name}", value)
+                record_mutation(name, value)
               end
             end
           end
@@ -169,6 +176,11 @@ module Lutaml
         def attribute(name, type, options = {})
           type, options = process_type_hash(type, options) if type.is_a?(::Hash)
 
+          if type.is_a?(::Array)
+            options = options.merge(union_member_types: type)
+            type = Lutaml::Model::Type::Union
+          end
+
           # Handle direct method option in options hash
           if options[:method]
             options[:method_name] = options.delete(:method)

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

@@ -39,8 +39,10 @@ module Lutaml
 
           return self unless block
 
-          # Enable order tracking for mixed_content models
-          @__order_tracking__ = mixed_content?
+          # Enable order tracking for ordered and mixed_content models.
+          # `ordered?` is true for both `ordered` and `mixed_content`
+          # (mixed_content sets @ordered = true in addition to @mixed_content).
+          @__order_tracking__ = ordered?
 
           # Evaluate the block - use instance_eval for no-receiver style
           # The block's first parameter determines the style:
@@ -62,6 +64,72 @@ module Lutaml
           mapping&.mixed_content? || false
         end
 
+        # Check if this model has ordered or mixed_content enabled.
+        # Both set @ordered = true on the XML mapping; mixed_content
+        # additionally sets @mixed_content = true. Order tracking is
+        # needed for either mode so the builder can emit elements in
+        # setter-call order rather than declaration order.
+        # @return [Boolean]
+        def ordered?
+          mapping = self.class.mappings_for(:xml, lutaml_register)
+          mapping&.ordered? || false
+        end
+
+        # Whether this instance was constructed via a builder block and
+        # therefore records mutations into element_order. Parsed models
+        # and instances constructed without a block do not track; their
+        # element_order (if any) comes from the parser and is treated as
+        # the complete source of truth by the serializer.
+        # @return [Boolean]
+        def order_tracking_enabled?
+          @__order_tracking__ ? true : false
+        end
+
+        # Record a singular attribute mutation in element_order.
+        #
+        # No-op unless order tracking is enabled (i.e. the instance was
+        # constructed via a builder block on an ordered/mixed_content
+        # model). This is the single entry point for singular mutations
+        # and is called from generated setters and getter-with-arg paths
+        # so that direct setters (`x.foo = v`) and appender calls
+        # (`x.foo(v)`) behave identically.
+        #
+        # Returns `value` so generated setters preserve Ruby's setter
+        # contract: `obj.foo = v` evaluates to `v`. Callers like
+        # `obj.foo || (obj.foo = [])` depend on this.
+        #
+        # @param attribute_name [Symbol] The attribute being mutated
+        # @param value [Object, nil] The value being set; stored as text
+        #   content for content-mapped attributes, ignored otherwise
+        # @return [Object] the passed value
+        def record_mutation(attribute_name, value = nil)
+          return value unless @__order_tracking__
+
+          track_order(attribute_name, value, nil)
+          value
+        end
+
+        # Record a collection-attribute mutation in element_order.
+        #
+        # Emits one entry per item so that element_order length matches
+        # the number of serialized child elements. No-op when tracking
+        # is disabled, when the value is nil/empty, or when the
+        # collection's frozen sentinel is preserved (no real data).
+        #
+        # Returns `value` so generated setters preserve Ruby's setter
+        # contract (see {record_mutation}).
+        #
+        # @param attribute_name [Symbol] The collection attribute
+        # @param value [Object, nil] The value assigned to the collection
+        # @return [Object] the passed value
+        def record_mutation_collection(attribute_name, value)
+          return value unless @__order_tracking__
+          return value if value.nil? || Lutaml::Model::Utils.uninitialized?(value)
+
+          Array(value).each { |item| track_order(attribute_name, item, nil) }
+          value
+        end
+
         private
 
         # Intercept method calls to track order for mixed_content

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

@@ -370,7 +370,6 @@ module Lutaml
               instance_variable_get(:"@#{name}")
             else
               public_send(:"#{name}=", args.first)
-              track_order(name, args.first, nil) if @__order_tracking__
               args.first
             end
           end
@@ -380,6 +379,7 @@ module Lutaml
             reg_attr = resolve_register_attr(name)
             value = reg_attr.cast_value(value, lutaml_register)
             instance_variable_set(:"@#{name}", value)
+            record_mutation(name, value)
           end
         end
 
@@ -395,7 +395,7 @@ module Lutaml
               current = [] if current.equal?(LAZY_EMPTY_COLLECTION)
               new_value = current.is_a?(Array) ? current + [value] : value
               instance_variable_set(:"@#{name}", new_value)
-              track_order(name, value, nil) if @__order_tracking__
+              record_mutation(name, value)
               value
             end
           end
@@ -411,6 +411,7 @@ module Lutaml
             else
               instance_variable_set(:"@#{name}", value)
             end
+            record_mutation_collection(name, value)
           end
         end
 

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

@@ -71,71 +71,19 @@ module Lutaml
                                propagated.merge(register: instance.lutaml_register))
         end
 
-        # Apply a value map to transform a value
+        # Apply a value map to transform a value.
         #
-        # Handles nil, empty, and omitted values according to the value map.
+        # Delegates to Attribute#apply_value_map. See attribute.rb for the
+        # canonical implementation.
         #
         # @param value [Object] The value to transform
         # @param value_map [Hash] The value map configuration
         # @param attr [Attribute] The attribute definition
         # @return [Object] The transformed value
         def apply_value_map(value, value_map, attr)
-          if value.nil?
-            value_for_option(value_map[:nil], attr)
-          elsif Utils.empty?(value)
-            # Check for new boolean value_map format (from: { empty: true/false })
-            # Only use new format if the value is explicitly boolean (TrueClass or FalseClass)
-            if value_map[:from] && (value_map[:from][:empty].is_a?(TrueClass) || value_map[:from][:empty].is_a?(FalseClass))
-              return value_map[:from][:empty]
-            end
-            # Check for direct boolean format (rule.value_map(:from) returns { empty: true })
-            # Only return directly if it's a boolean value (TrueClass/FalseClass), not a symbol
-            if value_map[:empty].is_a?(TrueClass) || value_map[:empty].is_a?(FalseClass)
-              return value_map[:empty]
-            end
-
-            # Fall back to legacy value_map format
-            value_for_option(value_map[:empty], attr, value)
-          elsif Utils.uninitialized?(value)
-            # Check for new boolean value_map format (from: { omitted: true/false })
-            # Only use new format if the value is explicitly boolean (TrueClass or FalseClass)
-            if value_map[:from] && (value_map[:from][:omitted].is_a?(TrueClass) || value_map[:from][:omitted].is_a?(FalseClass))
-              return value_map[:from][:omitted]
-            end
-            # Check for direct boolean format (rule.value_map(:from) returns { omitted: false })
-            # Only return directly if it's a boolean value (TrueClass/FalseClass), not a symbol
-            if value_map[:omitted].is_a?(TrueClass) || value_map[:omitted].is_a?(FalseClass)
-              return value_map[:omitted]
-            end
+          return value unless attr
 
-            # Fall back to legacy value_map format
-            value_for_option(value_map[:omitted], attr)
-          else
-            value
-          end
-        end
-
-        # Get the value for a specific option in a value map
-        #
-        # @param option [Symbol] The option (:nil, :empty, etc.)
-        # @param attr [Attribute] The attribute definition
-        # @param empty_value [Object] The empty value to use (optional)
-        # @return [Object, nil, UninitializedClass] The appropriate value
-        def value_for_option(option, attr, empty_value = nil)
-          return nil if option == :nil
-          return empty_value || empty_object(attr) if option == :empty
-
-          Lutaml::Model::UninitializedClass.instance
-        end
-
-        # Get an empty object for an attribute
-        #
-        # @param attr [Attribute] The attribute definition
-        # @return [String, Array] Empty string or collection
-        def empty_object(attr)
-          return attr.build_collection if attr.collection?
-
-          ""
+          attr.apply_value_map(value, value_map)
         end
 
         # Ensure a value is UTF-8 encoded
@@ -145,6 +93,10 @@ module Lutaml
         def ensure_utf8(value)
           case value
           when String
+            # Opal strings are JS strings with no per-string encoding;
+            # String#encode there doesn't accept MRI's keyword options.
+            return value if Lutaml::Model.opal?
+
             value.encode("UTF-8", invalid: :replace, undef: :replace,
                                   replace: "")
           when Array

data/lib/lutaml/model/serialize.rb

@@ -202,9 +202,7 @@ module Lutaml
       def validate_attribute!(attr_name)
         attr = self.class.attributes[attr_name]
         value = instance_variable_get(:"@#{attr_name}")
-        resolver = Services::DefaultValueResolver.new(attr, lutaml_register,
-                                                      self)
-        attr.validate_value!(value, lutaml_register, resolver)
+        attr.validate_value!(value, lutaml_register, instance_object: self)
       end
 
       def key_exist?(hash, key)
@@ -301,12 +299,11 @@ module Lutaml
           return attr_value(attrs, name, attr)
         end
 
-        if attr.default_set?(lutaml_register, self)
-          using_default_for(name)
-          attr.default(lutaml_register, self)
-        else
-          Lutaml::Model::UninitializedClass.instance
-        end
+        resolved = attr.default_value(lutaml_register, self)
+        return Lutaml::Model::UninitializedClass.instance if Lutaml::Model::Utils.uninitialized?(resolved)
+
+        using_default_for(name)
+        attr.cast_value(resolved, lutaml_register)
       end
 
       def resolve_reference_key(ref)

data/lib/lutaml/model/services/rule_value_extractor.rb

@@ -50,9 +50,8 @@ instance_object)
         return fetch_value(name) if Utils.string_or_symbol_key?(doc, name)
 
         if attr
-          resolver = Services::DefaultValueResolver.new(attr, register,
-                                                        instance_object)
-          return resolver.default_value if resolver.default_set?
+          resolved = attr.default_value(register, instance_object)
+          return resolved unless Utils.uninitialized?(resolved)
         end
 
         uninitialized_value

data/lib/lutaml/model/services.rb

@@ -4,8 +4,6 @@ module Lutaml
   module Model
     module Services
       autoload :Base, "#{__dir__}/services/base"
-      autoload :DefaultValueResolver,
-               "#{__dir__}/services/default_value_resolver"
       autoload :Type, "#{__dir__}/services/type"
     end
   end

data/lib/lutaml/model/store.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
-require "weakref"
+# Opal has no `weakref` stdlib; runtime_compatibility.rb provides a stub.
+require "weakref" unless Lutaml::Model.opal?
 
 module Lutaml
   module Model

data/lib/lutaml/model/toml.rb

@@ -16,7 +16,7 @@ module Lutaml
       Transform = ::Lutaml::Toml::Adapter::Transform
 
       def self.detect_toml_adapter
-        return nil if Lutaml::Model::RuntimeCompatibility.opal?
+        return nil if Lutaml::Model.opal?
 
         # Skip tomlib on Windows entirely due to segfault issues
         if Lutaml::Model::RuntimeCompatibility.windows?

data/lib/lutaml/model/transform.rb

@@ -85,48 +85,26 @@ module Lutaml
       protected
 
       def apply_value_map(value, value_map, attr)
-        if value.nil?
-          value_for_option(value_map[:nil], attr)
-        elsif Utils.empty?(value)
-          # Check for boolean value_map format (value_map[:empty] is true/false)
-          # Only apply for Boolean type attributes
-          if value_map[:empty].is_a?(TrueClass) || value_map[:empty].is_a?(FalseClass)
-            # Check if attribute is a Boolean type
-            attr_type = attr&.type || attr&.unresolved_type
-            if attr_type == Lutaml::Model::Type::Boolean
-              return value_map[:empty]
-            end
-          end
-          value_for_option(value_map[:empty], attr, value)
-        elsif Utils.uninitialized?(value)
-          # Check for boolean value_map format (value_map[:omitted] is true/false)
-          # Only apply for Boolean type attributes
-          if value_map[:omitted].is_a?(TrueClass) || value_map[:omitted].is_a?(FalseClass)
-            # Check if attribute is a Boolean type
-            attr_type = attr&.type || attr&.unresolved_type
-            if attr_type == Lutaml::Model::Type::Boolean
-              return value_map[:omitted]
-            end
-          end
-          value_for_option(value_map[:omitted], attr)
-        else
-          value
+        return attr.apply_value_map(value, value_map) if attr
+
+        # Attribute-less dispatch for custom-method-only rules. Mirrors
+        # Attribute#apply_value_map for the options that need no attribute
+        # info: :nil -> nil and :omitted -> uninitialized. A typed :empty needs
+        # an Attribute (a crash case pre-consolidation), so the value passes
+        # through unchanged.
+        key = if value.nil? then :nil
+              elsif Utils.empty?(value) then :empty
+              elsif Utils.uninitialized?(value) then :omitted
+              end
+        return value unless key
+
+        case value_map[key]
+        when :nil then nil
+        when :empty then value
+        else Lutaml::Model::UninitializedClass.instance
         end
       end
 
-      def value_for_option(option, attr, empty_value = nil)
-        return nil if option == :nil
-        return empty_value || empty_object(attr) if option == :empty
-
-        Lutaml::Model::UninitializedClass.instance
-      end
-
-      def empty_object(attr)
-        return [] if attr.collection?
-
-        ""
-      end
-
       def mappings_for(format, register = nil)
         context.mappings_for(format, register)
       end

data/lib/lutaml/model/transformation_registry.rb

@@ -90,7 +90,7 @@ module Lutaml
 
       def initialize
         @transformations = {} # Cache for transformation instances (mutex-protected for cycle detection)
-        @mappings = if RuntimeCompatibility.opal?
+        @mappings = if Lutaml::Model.opal?
                       {}
                     else
                       Concurrent::Map.new

data/lib/lutaml/model/type.rb

@@ -16,6 +16,7 @@ module Lutaml
       autoload :Boolean, "#{__dir__}/type/boolean"
       autoload :Decimal, "#{__dir__}/type/decimal"
       autoload :Reference, "#{__dir__}/type/reference"
+      autoload :Union, "#{__dir__}/union"
       autoload :Hash, "#{__dir__}/type/hash"
       autoload :Symbol, "#{__dir__}/type/symbol"
       autoload :Duration, "#{__dir__}/type/duration"