lutaml-model 0.7.1 → 0.7.7

data/lib/lutaml/model/transform/key_value_transform.rb

@@ -0,0 +1,297 @@
+module Lutaml
+  module Model
+    class KeyValueTransform < Lutaml::Model::Transform
+      def data_to_model(data, format, options = {})
+        if model_class.include?(Lutaml::Model::Serialize)
+          instance = model_class.new(__register: __register)
+        else
+          instance = model_class.new
+          register_accessor_methods_for(instance, __register)
+        end
+        mappings = extract_mappings(options, format)
+
+        Utils.add_if_present(options, :key_mappings, mappings.key_mappings)
+        Utils.add_if_present(options, :value_mappings, mappings.value_mappings)
+
+        mappings.mappings.each do |rule|
+          process_mapping_rule(data, instance, format, rule, options)
+        end
+
+        instance
+      end
+
+      def model_to_data(instance, format, options = {})
+        mappings = extract_mappings(options, format)
+
+        hash = {}
+        mappings.mappings.each do |rule|
+          next unless valid_mapping?(rule, options)
+
+          process_rule!(instance, rule, hash, format, mappings, options)
+        end
+
+        hash.keys == [""] ? hash[""] : hash
+      end
+
+      private
+
+      def process_rule!(instance, rule, hash, format, mappings, options)
+        return handle_delegate(instance, rule, hash, format) if rule.delegate
+
+        value = process_mapping_for_instance(instance, hash, format, rule, options)
+
+        return unless mappings.key_value_mappings? && value
+
+        hash[rule_from_name(rule)] = handle_key_value_mappings(value, mappings)
+      end
+
+      def process_mapping_for_instance(instance, hash, format, rule, options)
+        if rule.custom_methods[:to]
+          return instance.send(rule.custom_methods[:to], instance, hash)
+        end
+
+        attribute = attributes[rule.to]
+        value = rule.serialize(instance)
+
+        return handle_raw_mapping(hash, value, format, options) if rule.raw_mapping?
+        return handle_root_mappings(hash, value, format, rule, attribute) if rule.root_mapping?
+
+        value = ExportTransformer.call(value, rule, attribute)
+
+        value = serialize_value(value, rule, attribute, format, options)
+
+        return unless rule.render?(value, instance)
+
+        value = apply_value_map(value, rule.value_map(:to, options), attribute)
+
+        hash[rule_from_name(rule)] = value
+      end
+
+      def valid_mapping?(rule, options)
+        only = options[:only]
+        except = options[:except]
+        name = rule.to
+
+        (except.nil? || !except.include?(name)) &&
+          (only.nil? || only.include?(name))
+      end
+
+      def handle_raw_mapping(hash, value, format, options)
+        result = Lutaml::Model::Config.adapter_for(format).parse(value, options)
+
+        hash.merge!(result)
+      end
+
+      def handle_root_mappings(hash, value, format, rule, attr)
+        hash.merge!(
+          generate_hash_from_child_mappings(
+            attr,
+            value,
+            format,
+            rule.root_mappings,
+          ),
+        )
+      end
+
+      def serialize_value(value, rule, attr, format, options)
+        return attr.serialize(value, format, __register, options) unless rule.child_mappings
+
+        generate_hash_from_child_mappings(
+          attr, value, format, rule.child_mappings
+        )
+      end
+
+      def rule_from_name(rule)
+        rule.multiple_mappings? ? rule.from.first.to_s : rule.from.to_s
+      end
+
+      def generate_hash_from_child_mappings(attr, value, format, child_mappings)
+        return value unless child_mappings
+
+        hash = {}
+
+        generate_remaining_mappings_for_value(child_mappings, value, format)
+
+        attr_type = attr.type(__register)
+        value.each do |child_obj|
+          rules = attr_type.mappings_for(format)
+
+          hash.merge!(
+            extract_hash_for_child_mapping(child_mappings, child_obj, rules, format),
+          )
+        end
+
+        hash
+      end
+
+      # Generates remaining child mappings for all attributes when only
+      # the :key mapping (e.g., { name: :key }) is provided.
+      # If any additional mappings (e.g., { name: :key, id: :identifier })
+      # are specified, no additional child mappings will be generated.
+      def generate_remaining_mappings_for_value(child_mappings, value, format)
+        return if child_mappings.values != [:key]
+
+        klass = value.first.class
+        mappings = klass.mappings_for(format)
+
+        klass.attributes.each_key do |name|
+          next if Utils.string_or_symbol_key?(child_mappings, name)
+
+          child_mappings[name.to_sym] = child_mapping_for(name, mappings)
+        end
+      end
+
+      def child_mapping_for(name, mappings)
+        mappings.find_by_to(name)&.name.to_s
+      end
+
+      def extract_hash_for_child_mapping(child_mappings, child_obj, rules, format)
+        key = nil
+        value = {}
+
+        child_mappings.each do |attr_name, path|
+          rule = rules.find_by_to(attr_name)
+          attr_value = normalize_attribute_value(child_obj, rule.from, format)
+
+          next unless rule&.render?(attr_value, nil)
+          next key = attr_value if path == :key
+
+          value = extract_hash_value_for_child_mapping(path, attr_value, value)
+        end
+
+        value = nil if value.empty?
+        { key => value }
+      end
+
+      def normalize_attribute_value(value, attr_name, format)
+        Lutaml::Model::Config.adapter_for(format).parse(
+          value.public_send(:"to_#{format}"),
+        )[attr_name.to_s]
+      end
+
+      def extract_hash_value_for_child_mapping(path, value, map_value)
+        return value if path == :value
+
+        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, value)
+
+        map_value
+      end
+
+      def handle_delegate(instance, rule, hash, format)
+        value = extract_value_for_delegate(instance, rule)
+        return if value.nil? && !rule.render_nil
+
+        attribute = instance.send(rule.delegate).class.attributes[rule.to]
+        hash[rule_from_name(rule)] = attribute.serialize(value, format, __register)
+      end
+
+      def extract_value_for_delegate(instance, rule)
+        instance.send(rule.delegate).send(rule.to)
+      end
+
+      def extract_mappings(options, format)
+        options[:mappings] || mappings_for(format)
+      end
+
+      def process_mapping_rule(doc, instance, format, rule, options = {})
+        attr = attribute_for_rule(rule)
+        return if attr&.derived?
+
+        raise "Attribute '#{rule.to}' not found in #{self}" unless valid_rule?(rule, attr)
+
+        value = rule_value_extractor_class.call(rule, doc, format, attr, __register, options)
+        value = apply_value_map(value, rule.value_map(:from, options), attr)
+
+        return process_custom_method(rule, instance, value) if rule.has_custom_method_for_deserialization?
+
+        value = translate_mappings(value, rule.hash_mappings, attr, format)
+        value = cast_value(value, attr, format, rule) unless rule.hash_mappings
+
+        attr.valid_collection!(value, context)
+        rule.deserialize(instance, value, attributes, self)
+      end
+
+      def process_custom_method(rule, instance, value)
+        return unless Utils.present?(value)
+
+        model_class.new.send(rule.custom_methods[:from], instance, value)
+      end
+
+      def cast_value(value, attr, format, rule)
+        cast_options = rule.polymorphic ? { polymorphic: rule.polymorphic } : {}
+        attr.cast(value, format, __register, cast_options)
+      end
+
+      def translate_mappings(hash, child_mappings, attr, format)
+        return hash unless child_mappings
+
+        hash.map do |key, value|
+          process_child_mapping(key, value, child_mappings, attr, format, hash)
+        end
+      end
+
+      def process_child_mapping(key, value, child_mappings, attr, format, hash)
+        child_hash = build_child_hash(key, value, child_mappings, attr, format)
+
+        if only_keys_mapped?(child_mappings, hash)
+          child_hash.merge!(value)
+        end
+
+        map_child_data(child_hash, attr, format)
+      end
+
+      def build_child_hash(key, value, child_mappings, attr, format)
+        attr_type = attr.type(__register)
+        child_mappings.to_h do |attr_name, path|
+          attr_value = extract_attr_value(path, key, value)
+          attr_rule = attr_type.mappings_for(format).find_by_to(attr_name)
+          [attr_rule.from.to_s, attr_value]
+        end
+      end
+
+      def extract_attr_value(path, key, value)
+        case path
+        when :key then key
+        when :value then value
+        else
+          path = Array(path)
+          value.dig(*path.map(&:to_s))
+        end
+      end
+
+      def only_keys_mapped?(child_mappings, hash)
+        child_mappings.values == [:key] && hash.values.all?(Hash)
+      end
+
+      def map_child_data(child_hash, attr, format)
+        attr_type = attr.type(__register)
+        self.class.data_to_model(
+          attr_type,
+          child_hash,
+          format,
+          { mappings: attr_type.mappings_for(format) },
+        )
+      end
+
+      def handle_key_value_mappings(value, mappings)
+        value.to_h do |v|
+          [
+            v[mappings.key_mappings.to_instance.to_s],
+            if mappings.value_mappings
+              v[mappings.value_mappings.as_attribute.to_s]
+            else
+              v.except(mappings.key_mappings.to_instance.to_s)
+            end,
+          ]
+        end
+      end
+
+      def rule_value_extractor_class
+        Lutaml::Model::RuleValueExtractor
+      end
+    end
+  end
+end

data/lib/lutaml/model/transform/xml_transform.rb

@@ -0,0 +1,228 @@
+module Lutaml
+  module Model
+    class XmlTransform < Lutaml::Model::Transform
+      def data_to_model(data, _format, options = {})
+        if model_class.include?(Lutaml::Model::Serialize)
+          instance = model_class.new({ __register: __register })
+        else
+          instance = model_class.new
+          register_accessor_methods_for(instance, __register)
+        end
+        apply_xml_mapping(data, instance, options)
+      end
+
+      # TODO: this should be extracted from adapters and moved here to be reused
+      def model_to_data(model, _format, _options = {})
+        model
+      end
+
+      private
+
+      def apply_xml_mapping(doc, instance, options = {})
+        options = prepare_options(options)
+        instance.encoding = options[:encoding]
+        return instance unless doc
+
+        mappings = options[:mappings] || mappings_for(:xml).mappings
+
+        validate_document!(doc, options)
+
+        set_instance_ordering(instance, doc, options)
+        set_schema_location(instance, doc)
+
+        defaults_used = []
+        validate_sequence!(doc.root.order)
+
+        mappings.each do |rule|
+          attr = attribute_for_rule(rule)
+          next if attr&.derived?
+
+          raise "Attribute '#{rule.to}' not found in #{context}" unless valid_rule?(rule, attr)
+
+          new_opts = options.dup
+          if rule.namespace_set?
+            new_opts[:default_namespace] = rule.namespace
+          end
+
+          value = if rule.raw_mapping?
+                    doc.root.inner_xml
+                  elsif rule.content_mapping?
+                    rule.cdata ? doc.cdata : doc.text
+                  else
+                    val = value_for_rule(doc, rule, new_opts, instance)
+
+                    if (val.nil? || Utils.uninitialized?(val)) && (instance.using_default?(rule.to) || rule.render_default)
+                      defaults_used << rule.to
+                      attr&.default(__register) || rule.to_value_for(instance)
+                    else
+                      val
+                    end
+                  end
+
+          value = apply_value_map(value, rule.value_map(:from, new_opts), attr)
+          value = normalize_xml_value(value, rule, attr, new_opts)
+          rule.deserialize(instance, value, attributes, context)
+        end
+
+        defaults_used.each do |attr_name|
+          instance.using_default_for(attr_name)
+        end
+
+        instance
+      end
+
+      def prepare_options(options)
+        opts = Utils.deep_dup(options)
+        opts[:default_namespace] ||= mappings_for(:xml)&.namespace_uri
+
+        opts
+      end
+
+      def validate_document!(doc, options)
+        return unless doc.is_a?(Array)
+
+        raise Lutaml::Model::CollectionTrueMissingError(
+          context,
+          options[:caller_class],
+        )
+      end
+
+      def set_instance_ordering(instance, doc, options)
+        return unless instance.respond_to?(:ordered=)
+
+        instance.element_order = doc.root.order
+        instance.ordered = mappings_for(:xml).ordered? || options[:ordered]
+        instance.mixed = mappings_for(:xml).mixed_content? || options[:mixed_content]
+      end
+
+      def set_schema_location(instance, doc)
+        schema_location = doc.attributes.values.find do |a|
+          a.unprefixed_name == "schemaLocation"
+        end
+
+        return 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
+
+      def value_for_rule(doc, rule, options, instance)
+        rule_names = rule.namespaced_names(options[:default_namespace])
+        return doc.root.find_attribute_value(rule_names) if rule.attribute?
+
+        attr = attribute_for_rule(rule)
+        attr_type = attr&.type(__register)
+
+        children = doc.children.select do |child|
+          rule_names.include?(child.namespaced_name) && !child.text?
+        end
+
+        if rule.has_custom_method_for_deserialization? || 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
+
+        return handle_cdata(children) if rule.cdata
+        return Lutaml::Model::UninitializedClass.instance if children.empty?
+
+        values = attr.build_collection
+
+        instance.value_set_for(attr.name)
+
+        children.each do |child|
+          if !rule.has_custom_method_for_deserialization? && attr_type <= Serialize
+            cast_options = options.except(:mappings)
+            cast_options[:polymorphic] = rule.polymorphic if rule.polymorphic
+            cast_options[:register] = __register
+
+            values << attr.cast(child, :xml, __register, cast_options)
+          elsif attr.raw?
+            values << inner_xml_of(child)
+          else
+            return nil if rule.render_nil_as_nil? && child.nil_element?
+
+            text = child.nil_element? ? nil : (child&.text&.+ child&.cdata)
+            values << text
+          end
+        end
+
+        normalized_value_for_attr(values, attr)
+      end
+
+      def handle_cdata(children)
+        values = children.map do |child|
+          child.cdata_children&.map(&:text)
+        end.flatten
+
+        children.count > 1 ? values : values.first
+      end
+
+      def normalized_value_for_attr(values, attr)
+        # for xml collection: true cases like
+        #   <store><items /></store>
+        #   <store><items xsi:nil="true"/></store>
+        #   <store><items></items></store>
+        #
+        # these are considered empty collection
+        return [] if attr&.collection? && [[nil], [""]].include?(values)
+        return values if attr&.collection?
+
+        values.is_a?(Array) ? values.first : values
+      end
+
+      def normalize_xml_value(value, rule, attr, options = {})
+        collection_class = attr&.collection_class || Array
+        value = [value].compact if !value.nil? && attr&.collection? && !value.is_a?(collection_class)
+
+        return value unless cast_value?(attr, rule)
+
+        attr.cast(value, :xml, __register, options)
+      end
+
+      def cast_value?(attr, rule)
+        attr && rule.castable?
+      end
+
+      def ensure_utf8(value)
+        case value
+        when String
+          value.encode("UTF-8", invalid: :replace, undef: :replace,
+                                replace: "")
+        when Array
+          value.map { |v| ensure_utf8(v) }
+        when Hash
+          value.transform_keys do |k|
+            ensure_utf8(k)
+          end.transform_values do |v|
+            ensure_utf8(v)
+          end
+        else
+          value
+        end
+      end
+
+      def inner_xml_of(node)
+        case node
+        when Xml::XmlElement
+          node.inner_xml
+        else
+          node.children.map(&:to_xml).join
+        end
+      end
+
+      def validate_sequence!(element_order)
+        mapping_sequence = mappings_for(:xml).element_sequence
+        return if mapping_sequence.empty?
+
+        current_order = element_order.filter_map(&:element_tag)
+
+        mapping_sequence.each do |mapping|
+          mapping.validate_content!(current_order, context)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/transform.rb

@@ -0,0 +1,93 @@
+module Lutaml
+  module Model
+    class Transform
+      def self.data_to_model(context, data, format, options = {})
+        new(context, options[:register]).data_to_model(data, format, options)
+      end
+
+      def self.model_to_data(context, model, format, options = {})
+        register = model.__register if model.respond_to?(:__register)
+        new(context, register).model_to_data(model, format, options)
+      end
+
+      attr_reader :context, :attributes, :__register
+
+      def initialize(context, register = nil)
+        @context = context
+        @attributes = context.attributes
+        @__register = register || Lutaml::Model::Config.default_register
+      end
+
+      def model_class
+        @context.model
+      end
+
+      def data_to_model(data, options = {})
+        raise NotImplementedError, "#{self.class.name} must implement `data_to_model`."
+      end
+
+      def model_to_data(model, options = {})
+        raise NotImplementedError, "#{self.class.name} must implement `model_to_data`."
+      end
+
+      protected
+
+      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
+      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)
+        context.mappings_for(format)
+      end
+
+      def defined_mappings_for(format)
+        context.mappings[format]
+      end
+
+      def valid_rule?(rule, attribute)
+        attribute || rule.custom_methods[:from]
+      end
+
+      def attribute_for_rule(rule)
+        return attributes[rule.to] unless rule.delegate
+
+        attributes[rule.delegate].type(__register).attributes[rule.to]
+      end
+
+      def register_accessor_methods_for(object, register)
+        klass = object.class
+        Utils.add_method_if_not_defined(klass, :__register) do
+          @__register
+        end
+        Utils.add_method_if_not_defined(klass, :__register=) do |value|
+          @__register = value
+        end
+        object.__register = register
+      end
+    end
+  end
+end
+
+require_relative "transform/key_value_transform"
+require_relative "transform/xml_transform"

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

@@ -2,7 +2,7 @@ module Lutaml
   module Model
     module Type
       class Boolean < Value
-        def self.cast(value)
+        def self.cast(value, _options = {})
           return nil if value.nil?
           return true if value == true || value.to_s.match?(/^(true|t|yes|y|1)$/i)
           return false if value == false || value.to_s.match?(/^(false|f|no|n|0)$/i)

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

@@ -2,7 +2,7 @@ module Lutaml
   module Model
     module Type
       class Date < Value
-        def self.cast(value)
+        def self.cast(value, _options = {})
           return value if value.nil? || Utils.uninitialized?(value)
 
           case value

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

@@ -5,7 +5,7 @@ module Lutaml
     module Type
       # Date and time representation
       class DateTime < Value
-        def self.cast(value)
+        def self.cast(value, _options = {})
           return value if value.nil? || Utils.uninitialized?(value)
 
           case value

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

@@ -2,18 +2,20 @@ module Lutaml
   module Model
     module Type
       class Decimal < Value
-        def self.cast(value)
+        def self.cast(value, options = {})
           return nil if value.nil?
 
           check_dependencies!(value)
-          case value
-          when BigDecimal
-            # If already a BigDecimal, return as-is
-            value
-          else
-            # Convert to string first to handle various input types
-            BigDecimal(value.to_s)
-          end
+          value = case value
+                  when BigDecimal
+                    # If already a BigDecimal, return as-is
+                    value
+                  else
+                    # Convert to string first to handle various input types
+                    BigDecimal(value.to_s)
+                  end
+          Model::Services::Type::Validator::Number.validate!(value, options)
+          value
         rescue ArgumentError
           nil
         end

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

@@ -2,9 +2,10 @@ module Lutaml
   module Model
     module Type
       class Float < Value
-        def self.cast(value)
+        def self.cast(value, options = {})
           return nil if value.nil?
 
+          Model::Services::Type::Validator::Number.validate!(value, options)
           value.to_f
         end