lutaml-model 0.6.7 → 0.7.2

data/lib/lutaml/model/serialize.rb

@@ -1,12 +1,9 @@
-require_relative "yaml_adapter"
 require_relative "xml_adapter"
 require_relative "config"
 require_relative "type"
 require_relative "attribute"
-require_relative "mapping_rule"
 require_relative "mapping_hash"
-require_relative "xml_mapping"
-require_relative "key_value_mapping"
+# require_relative "mapping"
 require_relative "json_adapter"
 require_relative "comparable_model"
 require_relative "schema_location"
@@ -15,6 +12,7 @@ require_relative "error"
 require_relative "choice"
 require_relative "sequence"
 require_relative "liquefiable"
+require_relative "transform"
 
 module Lutaml
   module Model
@@ -94,22 +92,15 @@ module Lutaml
           end
         end
 
-        # Define an attribute for the model
-        def attribute(name, type, options = {})
-          if type.is_a?(Hash)
-            options[:method_name] = type[:method]
-            type = nil
-          end
-
-          attr = Attribute.new(name, type, options)
-          attributes[name] = attr
+        def define_attribute_methods(attr)
+          name = attr.name
 
           if attr.enum?
             add_enum_methods_to_model(
               model,
               name,
-              options[:values],
-              collection: options[:collection],
+              attr.options[:values],
+              collection: attr.options[:collection],
             )
           elsif attr.derived? && name != attr.method_name
             define_method(name) do
@@ -119,35 +110,75 @@ module Lutaml
             define_method(name) do
               instance_variable_get(:"@#{name}")
             end
-
             define_method(:"#{name}=") do |value|
               value_set_for(name)
               instance_variable_set(:"@#{name}", attr.cast_value(value))
             end
           end
+        end
+
+        # Define an attribute for the model
+        def attribute(name, type, options = {})
+          if type.is_a?(Hash)
+            options[:method_name] = type[:method]
+            type = nil
+          end
+
+          attr = Attribute.new(name, type, options)
+          attributes[name] = attr
+          define_attribute_methods(attr)
 
           attr
         end
 
         def root?
-          mappings_for(:xml).root?
+          mappings_for(:xml)&.root?
+        end
+
+        def import_model_with_root_error(model)
+          return unless model.mappings.key?(:xml) && model.root?
+
+          raise Lutaml::Model::ImportModelWithRootError.new(model)
         end
 
         def import_model_attributes(model)
-          raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
+          model.attributes.each_value do |attr|
+            define_attribute_methods(attr)
+          end
 
-          @attributes.merge!(model.attributes)
+          @choice_attributes.concat(Utils.deep_dup(model.choice_attributes))
+          @attributes.merge!(Utils.deep_dup(model.attributes))
         end
 
         def import_model_mappings(model)
-          raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
+          import_model_with_root_error(model)
+
+          Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
+            next unless model.mappings.key?(format)
+
+            mapping = model.mappings_for(format)
+            mapping = Utils.deep_dup(mapping)
+
+            klass = ::Lutaml::Model::Config.mappings_class_for(format)
+            @mappings[format] ||= klass.new
 
-          @mappings.merge!(model.mappings)
+            if format == :xml
+              @mappings[format].merge_mapping_attributes(mapping)
+              @mappings[format].merge_mapping_elements(mapping)
+              @mappings[format].merge_elements_sequence(mapping)
+            else
+              @mappings[format].mappings.concat(mapping.mappings)
+            end
+          end
         end
 
-        def import_model(model)
-          raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
+        def handle_key_value_mappings(mapping, format)
+          @mappings[format] ||= KeyValueMapping.new
+          @mappings[format].mappings.concat(mapping.mappings)
+        end
 
+        def import_model(model)
+          import_model_with_root_error(model)
           import_model_attributes(model)
           import_model_mappings(model)
         end
@@ -213,7 +244,8 @@ module Lutaml
 
         def add_enum_setter_if_not_defined(klass, enum_name, _values, collection)
           Utils.add_method_if_not_defined(klass, "#{enum_name}=") do |value|
-            value = [value] unless value.is_a?(Array)
+            value = [] if value.nil?
+            value = [value] if !value.is_a?(Array)
 
             value_set_for(enum_name)
 
@@ -231,140 +263,86 @@ module Lutaml
           attributes.select { |_, attr| attr.enum? }
         end
 
-        Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
-          define_method(format) do |&block|
-            klass = format == :xml ? XmlMapping : KeyValueMapping
-            mappings[format] ||= klass.new
-            mappings[format].instance_eval(&block)
+        def process_mapping(format, &block)
+          # klass = Lutaml::Model.const_get("#{format.to_s.capitalize}Mapping")
+          # mappings[format] ||= klass.new
+          # mappings[format].instance_eval(&block)
 
-            if format == :xml && !mappings[format].root_element && !mappings[format].no_root?
-              mappings[format].root(model.to_s)
-            end
-          end
+          # handle_root_assignment(mappings, format)
+
+          klass = ::Lutaml::Model::Config.mappings_class_for(format)
+          mappings[format] ||= klass.new
 
-          define_method(:"from_#{format}") do |data, options = {}|
-            adapter = Lutaml::Model::Config.send(:"#{format}_adapter")
+          mappings[format].instance_eval(&block)
 
-            doc = adapter.parse(data, options)
-            public_send(:"of_#{format}", doc, options)
+          if mappings[format].respond_to?(:finalize)
+            mappings[format].finalize(self)
           end
+        end
 
-          define_method(:"of_#{format}") do |doc, options = {}|
-            if doc.is_a?(Array)
-              return doc.map { |item| send(:"of_#{format}", item) }
-            end
+        def from(format, data, options = {})
+          return data if Utils.uninitialized?(data)
 
-            if format == :xml
-              raise Lutaml::Model::NoRootMappingError.new(self) unless root?
+          adapter = Lutaml::Model::Config.adapter_for(format)
 
-              options[:encoding] = doc.encoding
-              apply_mappings(doc, format, options)
-            else
-              apply_mappings(doc.to_h, format)
-            end
+          doc = adapter.parse(data, options)
+          public_send(:"of_#{format}", doc, options)
+        end
+
+        def of(format, doc, options = {})
+          if doc.is_a?(Array)
+            return doc.map { |item| send(:"of_#{format}", item) }
           end
 
-          define_method(:"to_#{format}") do |instance|
-            value = public_send(:"as_#{format}", instance)
-            adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
+          if format == :xml
+            raise Lutaml::Model::NoRootMappingError.new(self) unless root?
 
-            if format == :xml
-              xml_options = { mapper_class: self }
-              adapter.new(value).public_send(:"to_#{format}", xml_options)
-            else
-              adapter.new(value).public_send(:"to_#{format}")
-            end
+            options[:encoding] = doc.encoding
           end
 
-          define_method(:"as_#{format}") do |instance, options = {}|
-            if instance.is_a?(Array)
-              return instance.map { |item| public_send(:"as_#{format}", item) }
-            end
+          transformer = Lutaml::Model::Config.transformer_for(format)
+          transformer.data_to_model(self, doc, format, options)
+        end
 
-            unless instance.is_a?(model)
-              msg = "argument is a '#{instance.class}' but should be a '#{model}'"
-              raise Lutaml::Model::IncorrectModelError, msg
-            end
+        def to(format, instance, options = {})
+          value = public_send(:"as_#{format}", instance, options)
+          adapter = Lutaml::Model::Config.adapter_for(format)
 
-            return instance if format == :xml
+          options[:mapper_class] = self if format == :xml
 
-            hash_representation(instance, format, options)
-          end
+          adapter.new(value).public_send(:"to_#{format}", options)
         end
 
         def as(format, instance, options = {})
-          public_send(:"as_#{format}", instance, options)
+          if instance.is_a?(Array)
+            return instance.map { |item| public_send(:"as_#{format}", item) }
+          end
+
+          unless instance.is_a?(model)
+            msg = "argument is a '#{instance.class}' but should be a '#{model}'"
+            raise Lutaml::Model::IncorrectModelError, msg
+          end
+
+          transformer = Lutaml::Model::Config.transformer_for(format)
+          transformer.model_to_data(self, instance, format, options)
         end
 
         def key_value(&block)
           Lutaml::Model::Config::KEY_VALUE_FORMATS.each do |format|
-            mappings[format] ||= KeyValueMapping.new
+            mappings[format] ||= KeyValueMapping.new(format)
             mappings[format].instance_eval(&block)
           end
         end
 
-        def hash_representation(instance, format, options = {})
-          only = options[:only]
-          except = options[:except]
-          mappings = mappings_for(format).mappings
-
-          mappings.each_with_object({}) do |rule, hash|
-            name = rule.to
-            next if except&.include?(name) || (only && !only.include?(name))
-            next if !rule.custom_methods[:to] && (!rule.render_default? && instance.using_default?(rule.to))
-
-            next handle_delegate(instance, rule, hash, format) if rule.delegate
-
-            if rule.custom_methods[:to]
-              next instance.send(rule.custom_methods[:to], instance, hash)
-            end
-
-            value = instance.send(name)
-
-            if rule.raw_mapping?
-              adapter = Lutaml::Model::Config.send(:"#{format}_adapter")
-              return adapter.parse(value, options)
-            end
-
-            attribute = attributes[name]
-
-            if export_method = rule.transform[:export] || attribute.transform_export_method
-              value = export_method.call(value)
-            end
-
-            next hash.merge!(generate_hash_from_child_mappings(attribute, value, format, rule.root_mappings)) if rule.root_mapping?
-
-            value = if rule.child_mappings
-                      generate_hash_from_child_mappings(attribute, value, format, rule.child_mappings)
-                    else
-                      attribute.serialize(value, format, options)
-                    end
-
-            next unless rule.render?(value)
-
-            rule_from_name = rule.multiple_mappings? ? rule.from.first.to_s : rule.from.to_s
-            hash[rule_from_name] = value
-          end
-        end
-
-        def handle_delegate(instance, rule, hash, format)
-          name = rule.to
-          value = instance.send(rule.delegate).send(name)
-          return if value.nil? && !rule.render_nil
-
-          attribute = instance.send(rule.delegate).class.attributes[name]
-          rule_from_name = rule.multiple_mappings? ? rule.from.first.to_s : rule.from.to_s
-          hash[rule_from_name] = attribute.serialize(value, format)
-        end
-
         def mappings_for(format)
           mappings[format] || default_mappings(format)
         end
 
         def default_mappings(format)
-          klass = format == :xml ? XmlMapping : KeyValueMapping
+          klass = ::Lutaml::Model::Config.mappings_class_for(format)
+          mappings = klass.new
 
-          klass.new.tap do |mapping|
+          mappings.tap do |mapping|
             attributes&.each_key do |name|
               mapping.map_element(
                 name.to_s,
@@ -376,288 +354,55 @@ module Lutaml
           end
         end
 
-        def translate_mappings(hash, child_mappings, attr, format)
-          return hash unless child_mappings
-
-          hash.map do |key, value|
-            child_hash = child_mappings.to_h do |attr_name, path|
-              attr_value = if path == :key
-                             key
-                           elsif path == :value
-                             value
-                           else
-                             path = [path] unless path.is_a?(Array)
-                             value.dig(*path.map(&:to_s))
-                           end
-
-              attr_rule = attr.type.mappings_for(format).find_by_to(attr_name)
-              [attr_rule.from.to_s, attr_value]
-            end
-
-            if child_mappings.values == [:key] && hash.values.all?(Hash)
-              child_hash.merge!(value)
-            end
-
-            attr.type.apply_hash_mapping(
-              child_hash,
-              attr.type.model.new,
-              format,
-              { mappings: attr.type.mappings_for(format).mappings },
-            )
-          end
-        end
-
-        def generate_hash_from_child_mappings(attr, value, format, child_mappings)
-          return value unless child_mappings
-
-          hash = {}
-
-          if child_mappings.values == [:key]
-            klass = value.first.class
-            mappings = klass.mappings_for(format)
-
-            klass.attributes.each_key do |name|
-              next if child_mappings.key?(name.to_sym) || child_mappings.key?(name.to_s)
-
-              child_mappings[name.to_sym] = mappings.find_by_to(name)&.name.to_s || name.to_s
-            end
-          end
-
-          value.each do |child_obj|
-            map_key = nil
-            map_value = {}
-            mapping_rules = attr.type.mappings_for(format)
-
-            child_mappings.each do |attr_name, path|
-              mapping_rule = mapping_rules.find_by_to(attr_name)
-
-              attr_value = child_obj.send(attr_name)
-
-              attr_value = if attr_value.is_a?(Lutaml::Model::Serialize)
-                             attr_value.to_yaml_hash
-                           elsif attr_value.is_a?(Array) && attr_value.first.is_a?(Lutaml::Model::Serialize)
-                             attr_value.map(&:to_yaml_hash)
-                           else
-                             attr_value
-                           end
-
-              next unless mapping_rule&.render?(attr_value)
-
-              if path == :key
-                map_key = attr_value
-              elsif path == :value
-                map_value = attr_value
-              else
-                path = [path] unless path.is_a?(Array)
-                path[0...-1].inject(map_value) do |acc, k|
-                  acc[k.to_s] ||= {}
-                end.public_send(:[]=, path.last.to_s, attr_value)
-              end
-            end
-
-            map_value = nil if map_value.empty?
-            hash[map_key] = map_value
-          end
-
-          hash
-        end
-
-        def valid_rule?(rule)
-          attribute = attribute_for_rule(rule)
-
-          !!attribute || rule.custom_methods[:from]
-        end
-
-        def attribute_for_rule(rule)
-          return attributes[rule.to] unless rule.delegate
-
-          attributes[rule.delegate].type.attributes[rule.to]
-        end
-
-        def attribute_for_child(child_name, format)
-          mapping_rule = mappings_for(format).find_by_name(child_name)
-
-          attribute_for_rule(mapping_rule) if mapping_rule
-        end
-
         def apply_mappings(doc, format, options = {})
           instance = options[:instance] || model.new
           return instance if Utils.blank?(doc)
 
-          options[:mappings] = mappings_for(format).mappings
-
-          return apply_xml_mapping(doc, instance, options) if format == :xml
-
-          apply_hash_mapping(doc, instance, format, options)
-        end
-
-        def apply_xml_mapping(doc, instance, options = {})
-          options = Utils.deep_dup(options)
-          instance.encoding = options[:encoding]
-          return instance unless doc
-
-          if options[:default_namespace].nil?
-            options[:default_namespace] = mappings_for(:xml)&.namespace_uri
-          end
-          mappings = options[:mappings] || mappings_for(:xml).mappings
-
-          raise Lutaml::Model::CollectionTrueMissingError(self, option[:caller_class]) if doc.is_a?(Array)
+          mappings = mappings_for(format)
 
-          doc_order = doc.root.order
-          if instance.respond_to?(:ordered=)
-            instance.element_order = doc_order
-            instance.ordered = mappings_for(:xml).ordered? || options[:ordered]
-            instance.mixed = mappings_for(:xml).mixed_content? || options[:mixed_content]
+          if mappings.polymorphic_mapping
+            return resolve_polymorphic(doc, format, mappings, instance, options)
           end
 
-          schema_location = doc.attributes.values.find do |a|
-            a.unprefixed_name == "schemaLocation"
-          end
-
-          if !schema_location.nil?
-            instance.schema_location = Lutaml::Model::SchemaLocation.new(
-              schema_location: schema_location.value,
-              prefix: schema_location.namespace_prefix,
-              namespace: schema_location.namespace,
-            )
-          end
-
-          defaults_used = []
-          validate_sequence!(doc_order)
-
-          mappings.each do |rule|
-            raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
-
-            attr = attribute_for_rule(rule)
-            next if attr&.derived?
-
-            value = if rule.raw_mapping?
-                      doc.root.inner_xml
-                    elsif rule.content_mapping?
-                      rule.cdata ? doc.cdata : doc.text
-                    elsif val = value_for_rule(doc, rule, options, instance)
-                      val
-                    elsif instance.using_default?(rule.to) || rule.render_default
-                      defaults_used << rule.to
-                      attr&.default || rule.to_value_for(instance)
-                    end
-
-            value = normalize_xml_value(value, rule, attr, options)
-            rule.deserialize(instance, value, attributes, self)
-          end
-
-          defaults_used.each { |attr_name| instance.using_default_for(attr_name) }
-
-          instance
+          # options[:mappings] = mappings.mappings
+          transformer = Lutaml::Model::Config.transformer_for(format)
+          transformer.data_to_model(self, doc, format, options)
         end
 
-        def value_for_rule(doc, rule, options, instance)
-          rule_names = rule.namespaced_names(options[:default_namespace])
-
-          if rule.attribute?
-            doc.root.find_attribute_value(rule_names)
-          else
-            attr = attribute_for_rule(rule)
-            children = doc.children.select do |child|
-              rule_names.include?(child.namespaced_name) && !child.text?
-            end
-
-            if rule.using_custom_methods? || attr.type == Lutaml::Model::Type::Hash
-              return_child = attr.type == Lutaml::Model::Type::Hash || !attr.collection? if attr
-              return return_child ? children.first : children
-            end
+        def resolve_polymorphic(doc, format, mappings, instance, options = {})
+          polymorphic_mapping = mappings.polymorphic_mapping
+          return instance if polymorphic_mapping.polymorphic_map.empty?
 
-            if Utils.present?(children)
-              instance.value_set_for(attr.name)
-            end
-
-            if rule.cdata
-              values = children.map do |child|
-                child.cdata_children&.map(&:text)
-              end.flatten
-              return children.count > 1 ? values : values.first
-            end
+          klass_key = doc[polymorphic_mapping.name]
+          klass_name = polymorphic_mapping.polymorphic_map[klass_key]
+          klass = Object.const_get(klass_name)
 
-            values = children.map do |child|
-              if !rule.using_custom_methods? && attr.type <= Serialize
-                attr.cast(child, :xml, options.except(:mappings))
-              elsif attr.raw?
-                inner_xml_of(child)
-              else
-                child&.children&.first&.text
-              end
-            end
-            attr&.collection? ? values : values.first
-          end
+          klass.apply_mappings(doc, format, options)
         end
 
-        def apply_hash_mapping(doc, instance, format, options = {})
-          mappings = options[:mappings] || mappings_for(format).mappings
-          mappings.each do |rule|
-            raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule)
-
-            attr = attribute_for_rule(rule)
-
-            names = rule.multiple_mappings? ? rule.name : [rule.name]
-
-            value = names.collect do |rule_name|
-              if rule.root_mapping?
-                doc
-              elsif rule.raw_mapping?
-                adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
-                adapter.new(doc).public_send(:"to_#{format}")
-              elsif doc.key?(rule_name.to_s)
-                doc[rule_name.to_s]
-              elsif doc.key?(rule_name.to_sym)
-                doc[rule_name.to_sym]
-              else
-                attr&.default
-              end
-            end.compact.first
-
-            if rule.using_custom_methods?
-              if Utils.present?(value)
-                value = new.send(rule.custom_methods[:from], instance, value)
-              end
-
-              next
-            end
-
-            value = translate_mappings(value, rule.hash_mappings, attr, format)
-            value = attr.cast(value, format) unless rule.hash_mappings
-            attr.valid_collection!(value, self)
-
-            rule.deserialize(instance, value, attributes, self)
+        def apply_value_map(value, value_map, attr)
+          if value.nil?
+            value_for_option(value_map[:nil], attr)
+          elsif Utils.empty?(value)
+            value_for_option(value_map[:empty], attr, value)
+          elsif Utils.uninitialized?(value)
+            value_for_option(value_map[:omitted], attr)
+          else
+            value
           end
-
-          instance
         end
 
-        def normalize_xml_value(value, rule, attr, options = {})
-          value = [value].compact if attr&.collection? && !value.is_a?(Array)
-
-          return value unless cast_value?(attr, rule)
-
-          options.merge(caller_class: self, mixed_content: rule.mixed_content)
-          attr.cast(
-            value,
-            :xml,
-            options,
-          )
-        end
+        def value_for_option(option, attr, empty_value = nil)
+          return nil if option == :nil
+          return empty_value || empty_object(attr) if option == :empty
 
-        def cast_value?(attr, rule)
-          attr &&
-            !rule.raw_mapping? &&
-            !rule.content_mapping? &&
-            !rule.custom_methods[:from]
+          Lutaml::Model::UninitializedClass.instance
         end
 
-        def text_hash?(attr, value)
-          return false unless value.is_a?(Hash)
-          return value.one? && value.text? unless attr
+        def empty_object(attr)
+          return [] if attr.collection?
 
-          !(attr.type <= Serialize) && attr.type != Lutaml::Model::Type::Hash
+          ""
         end
 
         def ensure_utf8(value)
@@ -677,64 +422,61 @@ module Lutaml
             value
           end
         end
+      end
 
-        def validate_sequence!(element_order)
-          mapping_sequence = mappings_for(:xml).element_sequence
-          current_order = element_order.filter_map(&:element_tag)
+      def self.register_format_mapping_method(format)
+        method_name = format == :hash ? :hsh : format
 
-          mapping_sequence.each do |mapping|
-            mapping.validate_content!(current_order)
-          end
+        ::Lutaml::Model::Serialize::ClassMethods.define_method(method_name) do |&block|
+          process_mapping(format, &block)
         end
+      end
 
-        private
+      def self.register_from_format_method(format)
+        ClassMethods.define_method(:"from_#{format}") do |data, options = {}|
+          from(format, data, options)
+        end
 
-        def inner_xml_of(node)
-          case node
-          when XmlAdapter::XmlElement
-            node.inner_xml
-          else
-            node.children.map(&:to_xml).join
-          end
+        ClassMethods.define_method(:"of_#{format}") do |doc, options = {}|
+          of(format, doc, options)
         end
       end
 
-      attr_accessor :element_order, :schema_location, :encoding
-      attr_writer :ordered, :mixed
-
-      def initialize(attrs = {})
-        @using_default = {}
-
-        return unless self.class.attributes
+      def self.register_to_format_method(format)
+        ClassMethods.define_method(:"to_#{format}") do |instance, options = {}|
+          to(format, instance, options)
+        end
 
-        if attrs.is_a?(Lutaml::Model::MappingHash)
-          @ordered = attrs.ordered?
-          @element_order = attrs.item_order
+        ClassMethods.define_method(:"as_#{format}") do |instance, options = {}|
+          as(format, instance, options)
         end
 
-        if attrs.key?(:schema_location)
-          self.schema_location = attrs[:schema_location]
+        define_method(:"to_#{format}") do |options = {}|
+          raise Lutaml::Model::NoRootMappingError.new(self.class) if format == :xml && !self.class.root?
+
+          options[:parse_encoding] = encoding if encoding
+          self.class.to(format, self, options)
         end
+      end
 
-        self.class.attributes.each do |name, attr|
-          next if attr.derived?
+      attr_accessor :element_order, :schema_location, :encoding
+      attr_writer :ordered, :mixed
 
-          value = if attrs.key?(name) || attrs.key?(name.to_s)
-                    attr_value(attrs, name, attr)
-                  else
-                    using_default_for(name)
-                    attr.default
-                  end
+      def initialize(attrs = {}, options = {})
+        @using_default = {}
+        return unless self.class.attributes
 
-          # Initialize collections with an empty array if no value is provided
-          if attr.collection? && value.nil?
-            value = []
-          end
+        set_ordering(attrs)
+        set_schema_location(attrs)
+        initialize_attributes(attrs, options)
+      end
 
-          default = using_default?(name)
-          public_send(:"#{name}=", self.class.ensure_utf8(value))
-          using_default_for(name) if default
-        end
+      def value_map(options)
+        {
+          omitted: options[:omitted] || :nil,
+          nil: options[:nil] || :nil,
+          empty: options[:empty] || :empty,
+        }
       end
 
       def attr_value(attrs, name, attr_rule)
@@ -747,7 +489,7 @@ module Lutaml
                 end
 
         if attr_rule.collection? || value.is_a?(Array)
-          (value || []).map do |v|
+          value&.map do |v|
             if v.is_a?(Hash)
               attr_rule.type.new(v)
             else
@@ -776,7 +518,7 @@ module Lutaml
       end
 
       def method_missing(method_name, *args)
-        if method_name.to_s.end_with?("=") && self.class.attributes.key?(method_name.to_s.chomp("=").to_sym)
+        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
@@ -786,6 +528,17 @@ module Lutaml
         end
       end
 
+      def respond_to_missing?(method_name, include_private = false)
+        (method_name.to_s.end_with?("=") && attribute_exist?(method_name)) ||
+          super
+      end
+
+      def attribute_exist?(name)
+        name = name.to_s.chomp("=").to_sym if name.end_with?("=")
+
+        self.class.attributes.key?(name)
+      end
+
       def validate_attribute!(attr_name)
         attr = self.class.attributes[attr_name]
         value = instance_variable_get(:"@#{attr_name}")
@@ -816,20 +569,42 @@ module Lutaml
         self.class.as_yaml(self)
       end
 
-      Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
-        define_method(:"to_#{format}") do |options = {}|
-          adapter = Lutaml::Model::Config.public_send(:"#{format}_adapter")
-          raise Lutaml::Model::NoRootMappingError.new(self.class) unless self.class.root?
+      private
 
-          representation = if format == :xml
-                             self
-                           else
-                             self.class.hash_representation(self, format,
-                                                            options)
-                           end
+      def set_ordering(attrs)
+        return unless attrs.respond_to?(:ordered?)
 
-          options[:parse_encoding] = encoding if encoding
-          adapter.new(representation).public_send(:"to_#{format}", options)
+        @ordered = attrs.ordered?
+        @element_order = attrs.item_order
+      end
+
+      def set_schema_location(attrs)
+        return unless attrs.key?(:schema_location)
+
+        self.schema_location = attrs[:schema_location]
+      end
+
+      def initialize_attributes(attrs, options = {})
+        self.class.attributes.each do |name, attr|
+          next if attr.derived?
+
+          value = determine_value(attrs, name, attr)
+
+          default = using_default?(name)
+          value = self.class.apply_value_map(value, value_map(options), attr)
+          public_send(:"#{name}=", self.class.ensure_utf8(value))
+          using_default_for(name) if default
+        end
+      end
+
+      def determine_value(attrs, name, attr)
+        if attrs.key?(name) || attrs.key?(name.to_s)
+          attr_value(attrs, name, attr)
+        elsif attr.default_set?
+          using_default_for(name)
+          attr.default
+        else
+          Lutaml::Model::UninitializedClass.instance
         end
       end
     end