lutaml-model 0.6.7 → 0.7.2

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,11 +154,11 @@ 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)
+          if value.is_a?(Array) && !Utils.empty_collection?(value)
             value.each do |item|
               add_to_xml(xml, element, prefix, item, options)
             end
@@ -168,12 +168,18 @@ module Lutaml
 
           return if !render_element?(rule, element, value)
 
+          value = rule.render_value_for(value)
+
           if value && (attribute&.type&.<= Lutaml::Model::Serialize)
             handle_nested_elements(
               xml,
               value,
               options.merge({ rule: rule, attribute: attribute }),
             )
+          elsif value.nil?
+            xml.create_and_add_element(rule.name, attributes: { "xsi:nil" => true })
+          elsif Utils.empty?(value)
+            xml.create_and_add_element(rule.name)
           elsif rule.raw_mapping?
             xml.add_xml_fragment(xml, value)
           elsif rule.prefix_set?
@@ -205,19 +211,12 @@ module Lutaml
         end
 
         def build_unordered_element(xml, element, options = {})
-          mapper_class = options[:mapper_class] || element.class
+          mapper_class = determine_mapper_class(element, options)
           xml_mapping = mapper_class.mappings_for(:xml)
           return xml unless xml_mapping
 
-          attributes = options[:xml_attributes] ||= {}
-          attributes = build_attributes(element,
-                                        xml_mapping, options).merge(attributes)&.compact
-
-          prefix = if options.key?(:namespace_prefix)
-                     options[:namespace_prefix]
-                   elsif xml_mapping.namespace_prefix
-                     xml_mapping.namespace_prefix
-                   end
+          attributes = build_element_attributes(element, xml_mapping, options)
+          prefix = determine_namespace_prefix(options, xml_mapping)
 
           prefixed_xml = xml.add_namespace_prefix(prefix)
           tag_name = options[:tag_name] || xml_mapping.root_element
@@ -241,7 +240,7 @@ module Lutaml
               if attribute_def
                 value = attribute_value_for(element, element_rule)
 
-                next if value.nil? && !element_rule.render_nil?
+                next if !element_rule.render?(value, element)
 
                 value = [value] if attribute_def.collection? && !value.is_a?(Array)
               end
@@ -289,11 +288,7 @@ module Lutaml
         end
 
         def render_element?(rule, element, value)
-          render_default?(rule, element) && render_value?(rule, value)
-        end
-
-        def render_value?(rule, value)
-          rule.attribute? || rule.render_nil? || !value.nil?
+          rule.render?(value, element)
         end
 
         def render_default?(rule, element)
@@ -370,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
@@ -433,6 +430,29 @@ module Lutaml
         def cdata
           @root.cdata
         end
+
+        private
+
+        def determine_mapper_class(element, options)
+          if options[:mapper_class] && element.is_a?(options[:mapper_class])
+            element.class
+          else
+            options[:mapper_class] || element.class
+          end
+        end
+
+        def determine_namespace_prefix(options, mapping)
+          return options[:namespace_prefix] if options.key?(:namespace_prefix)
+
+          mapping.namespace_prefix
+        end
+
+        def build_element_attributes(element, mapping, options)
+          xml_attributes = options[:xml_attributes] ||= {}
+          attributes = build_attributes(element, mapping, options)
+
+          attributes.merge(xml_attributes)&.compact
+        end
       end
     end
   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

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

@@ -0,0 +1,410 @@
+require_relative "../mapping/mapping"
+require_relative "mapping_rule"
+
+module Lutaml
+  module Model
+    module Xml
+      class Mapping < Mapping
+        TYPES = {
+          attribute: :map_attribute,
+          element: :map_element,
+          content: :map_content,
+          all_content: :map_all,
+        }.freeze
+
+        attr_reader :root_element,
+                    :namespace_uri,
+                    :namespace_prefix,
+                    :mixed_content,
+                    :ordered,
+                    :element_sequence
+
+        def initialize
+          super
+
+          @elements = {}
+          @attributes = {}
+          @element_sequence = []
+          @content_mapping = nil
+          @raw_mapping = nil
+          @mixed_content = false
+          @format = :xml
+        end
+
+        def finalize(mapper_class)
+          if !root_element && !no_root?
+            root(mapper_class.model.to_s)
+          end
+        end
+
+        alias mixed_content? mixed_content
+        alias ordered? ordered
+
+        def root(name, mixed: false, ordered: false)
+          @root_element = name
+          @mixed_content = mixed
+          @ordered = ordered || mixed # mixed contenet will always be ordered
+        end
+
+        def root?
+          !!root_element
+        end
+
+        def no_root
+          @no_root = true
+        end
+
+        def no_root?
+          !!@no_root
+        end
+
+        def prefixed_root
+          if namespace_uri && namespace_prefix
+            "#{namespace_prefix}:#{root_element}"
+          else
+            root_element
+          end
+        end
+
+        def namespace(uri, prefix = nil)
+          raise Lutaml::Model::NoRootNamespaceError if no_root?
+
+          @namespace_uri = uri
+          @namespace_prefix = prefix
+        end
+
+        # rubocop:disable Metrics/ParameterLists
+        def map_element(
+          name,
+          to: nil,
+          render_nil: false,
+          render_default: false,
+          render_empty: false,
+          treat_nil: :nil,
+          treat_empty: :empty,
+          treat_omitted: :nil,
+          with: {},
+          delegate: nil,
+          cdata: false,
+          polymorphic: {},
+          namespace: (namespace_set = false
+                      nil),
+          prefix: (prefix_set = false
+                   nil),
+          transform: {},
+          value_map: {}
+        )
+          validate!(
+            name, to, with, render_nil, render_empty, type: TYPES[:element]
+          )
+
+          rule = MappingRule.new(
+            name,
+            to: to,
+            render_nil: render_nil,
+            render_default: render_default,
+            render_empty: render_empty,
+            treat_nil: treat_nil,
+            treat_empty: treat_empty,
+            treat_omitted: treat_omitted,
+            with: with,
+            delegate: delegate,
+            cdata: cdata,
+            namespace: namespace,
+            default_namespace: namespace_uri,
+            prefix: prefix,
+            polymorphic: polymorphic,
+            namespace_set: namespace_set != false,
+            prefix_set: prefix_set != false,
+            transform: transform,
+            value_map: value_map,
+          )
+          @elements[rule.namespaced_name] = rule
+        end
+
+        def map_attribute(
+          name,
+          to: nil,
+          render_nil: false,
+          render_default: false,
+          render_empty: false,
+          with: {},
+          delegate: nil,
+          polymorphic_map: {},
+          namespace: (namespace_set = false
+                      nil),
+          prefix: (prefix_set = false
+                   nil),
+          transform: {},
+          value_map: {}
+        )
+          validate!(
+            name, to, with, render_nil, render_empty, type: TYPES[:attribute]
+          )
+
+          if name == "schemaLocation"
+            Logger.warn_auto_handling(
+              name: name,
+              caller_file: File.basename(caller_locations(1, 1)[0].path),
+              caller_line: caller_locations(1, 1)[0].lineno,
+            )
+          end
+
+          rule = MappingRule.new(
+            name,
+            to: to,
+            render_nil: render_nil,
+            render_default: render_default,
+            with: with,
+            delegate: delegate,
+            namespace: namespace,
+            prefix: prefix,
+            attribute: true,
+            polymorphic_map: polymorphic_map,
+            default_namespace: namespace_uri,
+            namespace_set: namespace_set != false,
+            prefix_set: prefix_set != false,
+            transform: transform,
+            value_map: value_map,
+          )
+          @attributes[rule.namespaced_name] = rule
+        end
+
+        # rubocop:enable Metrics/ParameterLists
+
+        def map_content(
+          to: nil,
+          render_nil: false,
+          render_default: false,
+          render_empty: false,
+          with: {},
+          delegate: nil,
+          mixed: false,
+          cdata: false,
+          transform: {},
+          value_map: {}
+        )
+          validate!(
+            "content", to, with, render_nil, render_empty, type: TYPES[:content]
+          )
+
+          @content_mapping = MappingRule.new(
+            nil,
+            to: to,
+            render_nil: render_nil,
+            render_default: render_default,
+            render_empty: render_empty,
+            with: with,
+            delegate: delegate,
+            mixed_content: mixed,
+            cdata: cdata,
+            transform: transform,
+            value_map: value_map,
+          )
+        end
+
+        def map_all(
+          to:,
+          render_nil: false,
+          render_default: false,
+          delegate: nil,
+          with: {},
+          namespace: (namespace_set = false
+                      nil),
+          prefix: (prefix_set = false
+                   nil),
+          render_empty: false
+        )
+          validate!(
+            Constants::RAW_MAPPING_KEY,
+            to,
+            with,
+            render_nil,
+            render_empty,
+            type: TYPES[:all_content],
+          )
+
+          rule = MappingRule.new(
+            Constants::RAW_MAPPING_KEY,
+            to: to,
+            render_nil: render_nil,
+            render_default: render_default,
+            with: with,
+            delegate: delegate,
+            namespace: namespace,
+            prefix: prefix,
+            default_namespace: namespace_uri,
+            namespace_set: namespace_set != false,
+            prefix_set: prefix_set != false,
+          )
+
+          @raw_mapping = rule
+        end
+
+        alias map_all_content map_all
+
+        def sequence(&block)
+          @element_sequence << Sequence.new(self).tap do |s|
+            s.instance_eval(&block)
+          end
+        end
+
+        def import_model_mappings(model)
+          raise Lutaml::Model::ImportModelWithRootError.new(model) if model.root?
+
+          mappings = model.mappings_for(:xml)
+          @elements.merge!(mappings.instance_variable_get(:@elements))
+          @attributes.merge!(mappings.instance_variable_get(:@attributes))
+          (@element_sequence << mappings.element_sequence).flatten!
+        end
+
+        def validate!(key, to, with, render_nil, render_empty, type: nil)
+          validate_raw_mappings!(type)
+          validate_to_and_with_arguments!(key, to, with)
+
+          if render_nil == :as_empty || render_empty == :as_empty
+            raise IncorrectMappingArgumentsError.new(
+              ":as_empty is not supported for XML mappings",
+            )
+          end
+        end
+
+        def validate_to_and_with_arguments!(key, to, with)
+          if to.nil? && with.empty?
+            raise IncorrectMappingArgumentsError.new(
+              ":to or :with argument is required for mapping '#{key}'",
+            )
+          end
+
+          validate_with_options!(key, to, with)
+        end
+
+        def validate_with_options!(key, to, with)
+          return true if to
+
+          if !with.empty? && (with[:from].nil? || with[:to].nil?)
+            raise IncorrectMappingArgumentsError.new(
+              ":with argument for mapping '#{key}' requires :to and :from keys",
+            )
+          end
+        end
+
+        def validate_raw_mappings!(type)
+          if !@raw_mapping.nil? && type != TYPES[:attribute]
+            raise StandardError, "#{type} is not allowed, only #{TYPES[:attribute]} " \
+                                 "is allowed with #{TYPES[:all_content]}"
+          end
+
+          if !(elements.empty? && content_mapping.nil?) && type == TYPES[:all_content]
+            raise StandardError, "#{TYPES[:all_content]} is not allowed with other mappings"
+          end
+        end
+
+        def elements
+          @elements.values
+        end
+
+        def attributes
+          @attributes.values
+        end
+
+        def content_mapping
+          @content_mapping
+        end
+
+        def raw_mapping
+          @raw_mapping
+        end
+
+        def mappings
+          elements + attributes + [content_mapping, raw_mapping].compact
+        end
+
+        def element(name)
+          elements.detect do |rule|
+            name == rule.to
+          end
+        end
+
+        def attribute(name)
+          attributes.detect do |rule|
+            name == rule.to
+          end
+        end
+
+        def find_by_name(name)
+          if ["text", "#cdata-section"].include?(name.to_s)
+            content_mapping
+          else
+            mappings.detect do |rule|
+              rule.name == name.to_s || rule.name == name.to_sym
+            end
+          end
+        end
+
+        def mapping_attributes_hash
+          @attributes
+        end
+
+        def mapping_elements_hash
+          @elements
+        end
+
+        def merge_mapping_attributes(mapping)
+          mapping_attributes_hash.merge!(mapping.mapping_attributes_hash)
+        end
+
+        def merge_mapping_elements(mapping)
+          mapping_elements_hash.merge!(mapping.mapping_elements_hash)
+        end
+
+        def merge_elements_sequence(mapping)
+          mapping.element_sequence.each do |sequence|
+            element_sequence << Lutaml::Model::Sequence.new(self).tap do |instance|
+              sequence.attributes.each do |attr|
+                instance.attributes << attr.deep_dup
+              end
+            end
+          end
+        end
+
+        def deep_dup
+          self.class.new.tap do |xml_mapping|
+            xml_mapping.root(@root_element.dup, mixed: @mixed_content,
+                                                ordered: @ordered)
+            xml_mapping.namespace(@namespace_uri.dup, @namespace_prefix.dup)
+
+            attributes_to_dup.each do |var_name|
+              value = instance_variable_get(var_name)
+              xml_mapping.instance_variable_set(var_name, Utils.deep_dup(value))
+            end
+          end
+        end
+
+        def polymorphic_mapping
+          mappings.find(&:polymorphic_mapping?)
+        end
+
+        def attributes_to_dup
+          @attributes_to_dup ||= %i[
+            @content_mapping
+            @raw_mapping
+            @element_sequence
+            @attributes
+            @elements
+          ]
+        end
+
+        def dup_mappings(mappings)
+          new_mappings = {}
+
+          mappings.each do |key, mapping_rule|
+            new_mappings[key] = mapping_rule.deep_dup
+          end
+
+          new_mappings
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,141 @@
+require_relative "../mapping/mapping_rule"
+
+module Lutaml
+  module Model
+    module Xml
+      class MappingRule < MappingRule
+        attr_reader :namespace, :prefix, :mixed_content, :default_namespace, :cdata
+
+        def initialize(
+          name,
+          to:,
+          render_nil: false,
+          render_default: false,
+          render_empty: false,
+          treat_nil: nil,
+          treat_empty: nil,
+          treat_omitted: nil,
+          with: {},
+          delegate: nil,
+          namespace: nil,
+          prefix: nil,
+          mixed_content: false,
+          cdata: false,
+          namespace_set: false,
+          prefix_set: false,
+          attribute: false,
+          default_namespace: nil,
+          polymorphic: {},
+          polymorphic_map: {},
+          transform: {},
+          value_map: {}
+        )
+          super(
+            name,
+            to: to,
+            render_nil: render_nil,
+            render_default: render_default,
+            render_empty: render_empty,
+            treat_nil: treat_nil,
+            treat_empty: treat_empty,
+            treat_omitted: treat_omitted,
+            with: with,
+            delegate: delegate,
+            attribute: attribute,
+            polymorphic: polymorphic,
+            polymorphic_map: polymorphic_map,
+            transform: transform,
+            value_map: value_map,
+          )
+
+          @namespace = if namespace.to_s == "inherit"
+                       # we are using inherit_namespace in xml builder by
+                       # default so no need to do anything here.
+                       else
+                         namespace
+                       end
+          @prefix = prefix
+          @mixed_content = mixed_content
+          @cdata = cdata
+
+          @default_namespace = default_namespace
+
+          @namespace_set = namespace_set
+          @prefix_set = prefix_set
+        end
+
+        def namespace_set?
+          !!@namespace_set
+        end
+
+        def prefix_set?
+          !!@prefix_set
+        end
+
+        def content_mapping?
+          name.nil?
+        end
+
+        def content_key
+          cdata ? "#cdata-section" : "text"
+        end
+
+        def mixed_content?
+          !!@mixed_content
+        end
+
+        def prefixed_name
+          rule_name = multiple_mappings? ? name.first : name
+          if prefix
+            "#{prefix}:#{rule_name}"
+          else
+            rule_name
+          end
+        end
+
+        def namespaced_names(parent_namespace = nil)
+          if multiple_mappings?
+            name.map { |rule_name| namespaced_name(parent_namespace, rule_name) }
+          else
+            [namespaced_name(parent_namespace)]
+          end
+        end
+
+        def namespaced_name(parent_namespace = nil, name = self.name)
+          if name.to_s == "lang"
+            "#{prefix}:#{name}"
+          elsif namespace_set? || @attribute
+            [namespace, name].compact.join(":")
+          elsif default_namespace
+            "#{default_namespace}:#{name}"
+          else
+            [parent_namespace, name].compact.join(":")
+          end
+        end
+
+        def deep_dup
+          self.class.new(
+            name.dup,
+            to: to,
+            render_nil: render_nil,
+            render_default: render_default,
+            with: Utils.deep_dup(custom_methods),
+            delegate: delegate,
+            namespace: namespace.dup,
+            prefix: prefix.dup,
+            mixed_content: mixed_content,
+            cdata: cdata,
+            namespace_set: namespace_set?,
+            prefix_set: prefix_set?,
+            attribute: attribute,
+            polymorphic: polymorphic.dup,
+            default_namespace: default_namespace.dup,
+            transform: transform.dup,
+            render_empty: render_empty.dup,
+            value_map: Utils.deep_dup(@value_map),
+          )
+        end
+      end
+    end
+  end
+end