lutaml-model 0.7.1 → 0.7.2

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

@@ -0,0 +1,239 @@
+module Lutaml
+  module Model
+    class XmlTransform < Lutaml::Model::Transform
+      def data_to_model(data, _format, options = {})
+        instance = model_class.new
+        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|
+          raise "Attribute '#{rule.to}' not found in #{context}" unless valid_rule?(rule)
+
+          attr = attribute_for_rule(rule)
+          next if attr&.derived?
+
+          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 (Utils.uninitialized?(val) || val.nil?) && (instance.using_default?(rule.to) || rule.render_default)
+                      defaults_used << rule.to
+                      attr&.default || 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])
+
+        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.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
+
+          values = []
+
+          if Utils.present?(children)
+            instance.value_set_for(attr.name)
+          else
+            children = nil
+            values = Lutaml::Model::UninitializedClass.instance
+          end
+
+          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
+
+              values << attr.cast(child, :xml, 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
+      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 = {})
+        value = [value].compact if attr&.collection? && !value.is_a?(Array) && !value.nil?
+
+        return value unless cast_value?(attr, rule)
+
+        options.merge(caller_class: self, mixed_content: rule.mixed_content)
+        attr.cast(
+          value,
+          :xml,
+          options,
+        )
+      end
+
+      def cast_value?(attr, rule)
+        attr &&
+          !rule.raw_mapping? &&
+          !rule.content_mapping? &&
+          !rule.custom_methods[:from]
+      end
+
+      def text_hash?(attr, value)
+        return false unless value.is_a?(Hash)
+        return value.one? && value.text? unless attr
+
+        !(attr.type <= Serialize) && attr.type != Lutaml::Model::Type::Hash
+      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
+        current_order = element_order.filter_map(&:element_tag)
+
+        mapping_sequence.each do |mapping|
+          mapping.validate_content!(current_order)
+        end
+      end
+    end
+  end
+end

data/lib/lutaml/model/transform.rb

@@ -0,0 +1,78 @@
+module Lutaml
+  module Model
+    class Transform
+      def self.data_to_model(context, data, format, options = {})
+        new(context).data_to_model(data, format, options)
+      end
+
+      def self.model_to_data(context, model, format, options = {})
+        new(context).model_to_data(model, format, options)
+      end
+
+      attr_reader :context, :attributes
+
+      def initialize(context)
+        @context = context
+        @attributes = context.attributes
+      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 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
+    end
+  end
+end
+
+require_relative "transform/key_value_transform"
+require_relative "transform/xml_transform"

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

@@ -28,20 +28,17 @@ module Lutaml
           value.to_s
         end
 
-        # Format-specific instance methods
-        ::Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
-          define_method(:"to_#{format}") do
-            value
-          end
-        end
-
         # Class-level format conversion
         def self.from_format(value, format)
           new(send(:"from_#{format}", value))
         end
 
-        # Default format-specific class methods that can be overridden
-        ::Lutaml::Model::Config::AVAILABLE_FORMATS.each do |format|
+        # called from config when a new format is added
+        def self.register_format_to_from_methods(format)
+          define_method(:"to_#{format}") do
+            value
+          end
+
           define_singleton_method(:"from_#{format}") do |value|
             cast(value)
           end

data/lib/lutaml/model/uninitialized_class.rb

@@ -12,7 +12,7 @@ module Lutaml
       end
 
       def inspect
-        "unititialized"
+        "uninitialized"
       end
 
       def uninitialized?

data/lib/lutaml/model/utils.rb

@@ -63,6 +63,36 @@ module Lutaml
           value.respond_to?(:empty?) ? value.empty? : false
         end
 
+        # Check if the hash contains the given key in string or symbol format
+        # @param hash [Hash] the hash to check
+        # @param key [String, Symbol] the key to check
+        # @return [Boolean] true if the hash contains the key, false otherwise
+        # @example
+        #   hash = { "key" => "value" }
+        #   string_or_symbol_key?(hash, "key") # => true
+        #   string_or_symbol_key?(hash, :key) # => true
+        #   string_or_symbol_key?(hash, "invalid_key") # => false
+        def string_or_symbol_key?(hash, key)
+          hash.key?(key.to_s) || hash.key?(key.to_sym)
+        end
+
+        # Fetch the value from the hash using the key in string or symbol format
+        # @param hash [Hash] the hash to fetch the value from
+        # @param key [String, Symbol] the key to fetch the value for
+        # @return [Object] the value associated with the key
+        # @example
+        #   hash = { "key" => "value" }
+        #   fetch_with_string_or_symbol_key(hash, "key") # => "value"
+        #   fetch_with_string_or_symbol_key(hash, :key) # => "value"
+        #   fetch_with_string_or_symbol_key(hash, "invalid_key") # => nil
+        def fetch_with_string_or_symbol_key(hash, key)
+          if hash.key?(key.to_s)
+            hash[key.to_s]
+          elsif hash.key?(key.to_sym)
+            hash[key.to_sym]
+          end
+        end
+
         def add_method_if_not_defined(klass, method_name, &block)
           unless klass.method_defined?(method_name)
             klass.class_eval do

data/lib/lutaml/model/version.rb

@@ -2,6 +2,6 @@
 
 module Lutaml
   module Model
-    VERSION = "0.7.1"
+    VERSION = "0.7.2"
   end
 end

data/lib/lutaml/model/{xml_adapter → xml}/builder/nokogiri.rb

@@ -1,6 +1,6 @@
 module Lutaml
   module Model
-    module XmlAdapter
+    module Xml
       module Builder
         class Nokogiri
           def self.build(options = {})
@@ -84,7 +84,7 @@ module Lutaml
           end
 
           def method_missing(method_name, *args, &block)
-            if block_given?
+            if block
               xml.public_send(method_name, *args, &block)
             else
               xml.public_send(method_name, *args)

data/lib/lutaml/model/{xml_adapter → xml}/builder/oga.rb

@@ -2,7 +2,7 @@
 
 module Lutaml
   module Model
-    module XmlAdapter
+    module Xml
       module Builder
         class Oga
           def self.build(options = {}, &block)
@@ -12,7 +12,7 @@ module Lutaml
           attr_reader :document, :current_node, :encoding
 
           def initialize(options = {})
-            @document = XmlAdapter::Oga::Document.new
+            @document = Xml::Oga::Document.new
             @current_node = @document
             @encoding = options[:encoding]
             yield(self) if block_given?
@@ -23,7 +23,7 @@ module Lutaml
               name = "#{@current_namespace}:#{name}"
             end
 
-            if block_given?
+            if block
               element(name, attributes, &block)
             else
               element(name, attributes)
@@ -48,9 +48,9 @@ module Lutaml
 
           def add_element(oga_element, child)
             if child.is_a?(String)
-              current_element = oga_element.is_a?(XmlAdapter::Oga::Document) ? current_node : oga_element
+              current_element = oga_element.is_a?(Xml::Oga::Document) ? current_node : oga_element
               add_xml_fragment(current_element, child)
-            elsif oga_element.is_a?(XmlAdapter::Oga::Document)
+            elsif oga_element.is_a?(Xml::Oga::Document)
               oga_element.children.last.children << child
             else
               oga_element.children << child
@@ -62,7 +62,7 @@ module Lutaml
               name: name,
               value: value.to_s,
             )
-            if element.is_a?(XmlAdapter::Oga::Document)
+            if element.is_a?(Xml::Oga::Document)
               element.children.last.attributes << attribute
             else
               element.attributes << attribute
@@ -85,7 +85,7 @@ module Lutaml
                               element_name
                             end
 
-            if block_given?
+            if block
               element(prefixed_name, attributes, &block)
             else
               element(prefixed_name, attributes)
@@ -100,7 +100,7 @@ module Lutaml
             fragment = "<fragment>#{content}</fragment>"
             parsed_fragment = ::Oga.parse_xml(fragment)
             parsed_children = parsed_fragment.children.first.children
-            if element.is_a?(XmlAdapter::Oga::Document)
+            if element.is_a?(Xml::Oga::Document)
               element.children.last.children += parsed_children
             else
               element.children += parsed_children
@@ -116,7 +116,7 @@ module Lutaml
           end
 
           def append_text_node(element, oga_text)
-            if element.is_a?(XmlAdapter::Oga::Document)
+            if element.is_a?(Xml::Oga::Document)
               children = element.children
               children.empty? ? children << oga_text : children.last.children << oga_text
             else
@@ -126,7 +126,7 @@ module Lutaml
 
           def add_cdata(element, value)
             oga_cdata = ::Oga::XML::CData.new(text: value.to_s)
-            if element.is_a?(XmlAdapter::Oga::Document)
+            if element.is_a?(Xml::Oga::Document)
               element.children.last.children << oga_cdata
             else
               element.children << oga_cdata

data/lib/lutaml/model/{xml_adapter → xml}/builder/ox.rb

@@ -1,6 +1,6 @@
 module Lutaml
   module Model
-    module XmlAdapter
+    module Xml
       module Builder
         class Ox
           def self.build(options = {})

data/lib/lutaml/model/{xml_adapter/xml_document.rb → xml/document.rb}

@@ -6,8 +6,8 @@ require_relative "element"
 
 module Lutaml
   module Model
-    module XmlAdapter
-      class XmlDocument
+    module Xml
+      class Document
         attr_reader :root, :encoding
 
         def initialize(root, encoding = nil)
@@ -154,8 +154,8 @@ module Lutaml
           end
 
           # Only transform when recursion is not called
-          if (!attribute.collection? || value.is_a?(Array)) && transform_method = rule.transform[:export] || attribute.transform_export_method
-            value = transform_method.call(value)
+          if !attribute.collection? || value.is_a?(Array)
+            value = ExportTransformer.call(value, rule, attribute)
           end
 
           if value.is_a?(Array) && !Utils.empty_collection?(value)
@@ -233,7 +233,6 @@ module Lutaml
             end
 
             mappings = xml_mapping.elements + [xml_mapping.raw_mapping].compact
-
             mappings.each do |element_rule|
               attribute_def = attribute_definition_for(element, element_rule,
                                                        mapper_class: mapper_class)
@@ -271,8 +270,6 @@ module Lutaml
             text = content_rule.serialize(element)
             text = text.join if text.is_a?(Array)
 
-            return unless content_rule.render?(text, element)
-
             xml.add_text(xml, text, cdata: content_rule.cdata)
           end
         end
@@ -368,6 +365,8 @@ module Lutaml
             attr = attribute_definition_for(element, mapping_rule, mapper_class: options[:mapper_class])
             value = attr.serialize(value, :xml) if attr
 
+            value = ExportTransformer.call(value, mapping_rule, attr)
+
             if render_element?(mapping_rule, element, value)
               hash[mapping_rule.prefixed_name] = value ? value.to_s : value
             end

data/lib/lutaml/model/xml/element.rb

@@ -0,0 +1,32 @@
+module Lutaml
+  module Model
+    module Xml
+      class Element
+        attr_reader :type, :name
+
+        def initialize(type, name)
+          @type = type
+          @name = name
+        end
+
+        def text?
+          @type == "Text" && @name != "#cdata-section"
+        end
+
+        def element_tag
+          @name unless text?
+        end
+
+        def eql?(other)
+          return false unless other.is_a?(self.class)
+
+          instance_variables.all? do |var|
+            instance_variable_get(var) == other.instance_variable_get(var)
+          end
+        end
+
+        alias == eql?
+      end
+    end
+  end
+end